id
int32
0
167k
repo
stringlengths
5
54
path
stringlengths
4
155
func_name
stringlengths
1
118
original_string
stringlengths
52
85.5k
language
stringclasses
1 value
code
stringlengths
52
85.5k
code_tokens
sequence
docstring
stringlengths
6
2.61k
docstring_tokens
sequence
sha
stringlengths
40
40
url
stringlengths
85
252
0
jessevdk/go-assets
file.go
Close
func (f *File) Close() error { f.buf = nil f.dirIndex = 0 return nil }
go
func (f *File) Close() error { f.buf = nil f.dirIndex = 0 return nil }
[ "func", "(", "f", "*", "File", ")", "Close", "(", ")", "error", "{", "f", ".", "buf", "=", "nil", "\n", "f", ".", "dirIndex", "=", "0", "\n\n", "return", "nil", "\n", "}" ]
// Implementation of http.File
[ "Implementation", "of", "http", ".", "File" ]
4f4301a06e153ff90e17793577ab6bf79f8dc5c5
https://github.com/jessevdk/go-assets/blob/4f4301a06e153ff90e17793577ab6bf79f8dc5c5/file.go#L57-L62
1
jessevdk/go-assets
filesystem.go
Open
func (f *FileSystem) Open(p string) (http.File, error) { p = path.Clean(p) if len(f.LocalPath) != 0 { return http.Dir(f.LocalPath).Open(p) } if fi, ok := f.Files[p]; ok { if !fi.IsDir() { // Make a copy for reading ret := fi ret.buf = bytes.NewReader(ret.Data) return ret, nil } return fi, nil } return nil, os.ErrNotExist }
go
func (f *FileSystem) Open(p string) (http.File, error) { p = path.Clean(p) if len(f.LocalPath) != 0 { return http.Dir(f.LocalPath).Open(p) } if fi, ok := f.Files[p]; ok { if !fi.IsDir() { // Make a copy for reading ret := fi ret.buf = bytes.NewReader(ret.Data) return ret, nil } return fi, nil } return nil, os.ErrNotExist }
[ "func", "(", "f", "*", "FileSystem", ")", "Open", "(", "p", "string", ")", "(", "http", ".", "File", ",", "error", ")", "{", "p", "=", "path", ".", "Clean", "(", "p", ")", "\n\n", "if", "len", "(", "f", ".", "LocalPath", ")", "!=", "0", "{", "return", "http", ".", "Dir", "(", "f", ".", "LocalPath", ")", ".", "Open", "(", "p", ")", "\n", "}", "\n\n", "if", "fi", ",", "ok", ":=", "f", ".", "Files", "[", "p", "]", ";", "ok", "{", "if", "!", "fi", ".", "IsDir", "(", ")", "{", "// Make a copy for reading", "ret", ":=", "fi", "\n", "ret", ".", "buf", "=", "bytes", ".", "NewReader", "(", "ret", ".", "Data", ")", "\n\n", "return", "ret", ",", "nil", "\n", "}", "\n\n", "return", "fi", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "os", ".", "ErrNotExist", "\n", "}" ]
// Implementation of http.FileSystem
[ "Implementation", "of", "http", ".", "FileSystem" ]
4f4301a06e153ff90e17793577ab6bf79f8dc5c5
https://github.com/jessevdk/go-assets/blob/4f4301a06e153ff90e17793577ab6bf79f8dc5c5/filesystem.go#L50-L70
2
jessevdk/go-assets
generate.go
Add
func (x *Generator) Add(p string) error { if x.fsFilesMap == nil { x.fsFilesMap = make(map[string]file) } if x.fsDirsMap == nil { x.fsDirsMap = make(map[string][]string) } p = path.Clean(p) info, err := os.Stat(p) if err != nil { return err } prefix, p := x.splitRelPrefix(p) if err := x.addParents(p, prefix); err != nil { return err } return x.addPath(path.Dir(p), prefix, info) }
go
func (x *Generator) Add(p string) error { if x.fsFilesMap == nil { x.fsFilesMap = make(map[string]file) } if x.fsDirsMap == nil { x.fsDirsMap = make(map[string][]string) } p = path.Clean(p) info, err := os.Stat(p) if err != nil { return err } prefix, p := x.splitRelPrefix(p) if err := x.addParents(p, prefix); err != nil { return err } return x.addPath(path.Dir(p), prefix, info) }
[ "func", "(", "x", "*", "Generator", ")", "Add", "(", "p", "string", ")", "error", "{", "if", "x", ".", "fsFilesMap", "==", "nil", "{", "x", ".", "fsFilesMap", "=", "make", "(", "map", "[", "string", "]", "file", ")", "\n", "}", "\n\n", "if", "x", ".", "fsDirsMap", "==", "nil", "{", "x", ".", "fsDirsMap", "=", "make", "(", "map", "[", "string", "]", "[", "]", "string", ")", "\n", "}", "\n\n", "p", "=", "path", ".", "Clean", "(", "p", ")", "\n\n", "info", ",", "err", ":=", "os", ".", "Stat", "(", "p", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "prefix", ",", "p", ":=", "x", ".", "splitRelPrefix", "(", "p", ")", "\n\n", "if", "err", ":=", "x", ".", "addParents", "(", "p", ",", "prefix", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "x", ".", "addPath", "(", "path", ".", "Dir", "(", "p", ")", ",", "prefix", ",", "info", ")", "\n", "}" ]
// Add a file or directory asset to the generator. Added directories will be // recursed automatically.
[ "Add", "a", "file", "or", "directory", "asset", "to", "the", "generator", ".", "Added", "directories", "will", "be", "recursed", "automatically", "." ]
4f4301a06e153ff90e17793577ab6bf79f8dc5c5
https://github.com/jessevdk/go-assets/blob/4f4301a06e153ff90e17793577ab6bf79f8dc5c5/generate.go#L129-L153
3
jessevdk/go-assets
generate.go
Write
func (x *Generator) Write(wr io.Writer) error { p := x.PackageName if len(p) == 0 { p = "main" } variableName := x.VariableName if len(variableName) == 0 { variableName = "Assets" } writer := &bytes.Buffer{} // Write package and import fmt.Fprintf(writer, "package %s\n\n", p) fmt.Fprintln(writer, "import (") fmt.Fprintln(writer, "\t\"time\"") fmt.Fprintln(writer) fmt.Fprintln(writer, "\t\"github.com/jessevdk/go-assets\"") fmt.Fprintln(writer, ")") fmt.Fprintln(writer) vnames := make(map[string]string) // Write file contents as const strings if x.fsFilesMap != nil { // Create mapping from full file path to asset variable name. // This also reads the file and writes the contents as a const // string for k, v := range x.fsFilesMap { if v.info.IsDir() { continue } f, err := os.Open(v.path) if err != nil { return err } data, err := ioutil.ReadAll(f) f.Close() if err != nil { return err } s := sha1.New() io.WriteString(s, k) vname := fmt.Sprintf("_%s%x", variableName, s.Sum(nil)) vnames[k] = vname fmt.Fprintf(writer, "var %s = %#v\n", vname, string(data)) } fmt.Fprintln(writer) } fmt.Fprintf(writer, "// %s returns go-assets FileSystem\n", variableName) fmt.Fprintf(writer, "var %s = assets.NewFileSystem(", variableName) if x.fsDirsMap == nil { x.fsDirsMap = make(map[string][]string) } if x.fsFilesMap == nil { x.fsFilesMap = make(map[string]file) } dirmap := make(map[string][]string) for k, v := range x.fsDirsMap { if kk, ok := x.stripPrefix(k); ok { if len(kk) == 0 { kk = "/" } dirmap[kk] = v } } fmt.Fprintf(writer, "%#v, ", dirmap) fmt.Fprintf(writer, "map[string]*assets.File{\n") // Write files for k, v := range x.fsFilesMap { kk, ok := x.stripPrefix(k) if !ok { continue } if len(kk) == 0 { kk = "/" } mt := v.info.ModTime() var dt string if !v.info.IsDir() { dt = "[]byte(" + vnames[k] + ")" } else { dt = "nil" } fmt.Fprintf(writer, "\t\t%#v: &assets.File{\n", kk) fmt.Fprintf(writer, "\t\t\tPath: %#v,\n", kk) fmt.Fprintf(writer, "\t\t\tFileMode: %#v,\n", v.info.Mode()) fmt.Fprintf(writer, "\t\t\tMtime: time.Unix(%#v, %#v),\n", mt.Unix(), mt.UnixNano()) fmt.Fprintf(writer, "\t\t\tData: %s,\n", dt) fmt.Fprintf(writer, "\t\t},") } fmt.Fprintln(writer, "\t}, \"\")") ret, err := format.Source(writer.Bytes()) if err != nil { return err } wr.Write(ret) return nil }
go
func (x *Generator) Write(wr io.Writer) error { p := x.PackageName if len(p) == 0 { p = "main" } variableName := x.VariableName if len(variableName) == 0 { variableName = "Assets" } writer := &bytes.Buffer{} // Write package and import fmt.Fprintf(writer, "package %s\n\n", p) fmt.Fprintln(writer, "import (") fmt.Fprintln(writer, "\t\"time\"") fmt.Fprintln(writer) fmt.Fprintln(writer, "\t\"github.com/jessevdk/go-assets\"") fmt.Fprintln(writer, ")") fmt.Fprintln(writer) vnames := make(map[string]string) // Write file contents as const strings if x.fsFilesMap != nil { // Create mapping from full file path to asset variable name. // This also reads the file and writes the contents as a const // string for k, v := range x.fsFilesMap { if v.info.IsDir() { continue } f, err := os.Open(v.path) if err != nil { return err } data, err := ioutil.ReadAll(f) f.Close() if err != nil { return err } s := sha1.New() io.WriteString(s, k) vname := fmt.Sprintf("_%s%x", variableName, s.Sum(nil)) vnames[k] = vname fmt.Fprintf(writer, "var %s = %#v\n", vname, string(data)) } fmt.Fprintln(writer) } fmt.Fprintf(writer, "// %s returns go-assets FileSystem\n", variableName) fmt.Fprintf(writer, "var %s = assets.NewFileSystem(", variableName) if x.fsDirsMap == nil { x.fsDirsMap = make(map[string][]string) } if x.fsFilesMap == nil { x.fsFilesMap = make(map[string]file) } dirmap := make(map[string][]string) for k, v := range x.fsDirsMap { if kk, ok := x.stripPrefix(k); ok { if len(kk) == 0 { kk = "/" } dirmap[kk] = v } } fmt.Fprintf(writer, "%#v, ", dirmap) fmt.Fprintf(writer, "map[string]*assets.File{\n") // Write files for k, v := range x.fsFilesMap { kk, ok := x.stripPrefix(k) if !ok { continue } if len(kk) == 0 { kk = "/" } mt := v.info.ModTime() var dt string if !v.info.IsDir() { dt = "[]byte(" + vnames[k] + ")" } else { dt = "nil" } fmt.Fprintf(writer, "\t\t%#v: &assets.File{\n", kk) fmt.Fprintf(writer, "\t\t\tPath: %#v,\n", kk) fmt.Fprintf(writer, "\t\t\tFileMode: %#v,\n", v.info.Mode()) fmt.Fprintf(writer, "\t\t\tMtime: time.Unix(%#v, %#v),\n", mt.Unix(), mt.UnixNano()) fmt.Fprintf(writer, "\t\t\tData: %s,\n", dt) fmt.Fprintf(writer, "\t\t},") } fmt.Fprintln(writer, "\t}, \"\")") ret, err := format.Source(writer.Bytes()) if err != nil { return err } wr.Write(ret) return nil }
[ "func", "(", "x", "*", "Generator", ")", "Write", "(", "wr", "io", ".", "Writer", ")", "error", "{", "p", ":=", "x", ".", "PackageName", "\n\n", "if", "len", "(", "p", ")", "==", "0", "{", "p", "=", "\"", "\"", "\n", "}", "\n\n", "variableName", ":=", "x", ".", "VariableName", "\n\n", "if", "len", "(", "variableName", ")", "==", "0", "{", "variableName", "=", "\"", "\"", "\n", "}", "\n\n", "writer", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n\n", "// Write package and import", "fmt", ".", "Fprintf", "(", "writer", ",", "\"", "\\n", "\\n", "\"", ",", "p", ")", "\n", "fmt", ".", "Fprintln", "(", "writer", ",", "\"", "\"", ")", "\n", "fmt", ".", "Fprintln", "(", "writer", ",", "\"", "\\t", "\\\"", "\\\"", "\"", ")", "\n", "fmt", ".", "Fprintln", "(", "writer", ")", "\n", "fmt", ".", "Fprintln", "(", "writer", ",", "\"", "\\t", "\\\"", "\\\"", "\"", ")", "\n", "fmt", ".", "Fprintln", "(", "writer", ",", "\"", "\"", ")", "\n", "fmt", ".", "Fprintln", "(", "writer", ")", "\n\n", "vnames", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n\n", "// Write file contents as const strings", "if", "x", ".", "fsFilesMap", "!=", "nil", "{", "// Create mapping from full file path to asset variable name.", "// This also reads the file and writes the contents as a const", "// string", "for", "k", ",", "v", ":=", "range", "x", ".", "fsFilesMap", "{", "if", "v", ".", "info", ".", "IsDir", "(", ")", "{", "continue", "\n", "}", "\n\n", "f", ",", "err", ":=", "os", ".", "Open", "(", "v", ".", "path", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "data", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "f", ")", "\n\n", "f", ".", "Close", "(", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "s", ":=", "sha1", ".", "New", "(", ")", "\n", "io", ".", "WriteString", "(", "s", ",", "k", ")", "\n\n", "vname", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "variableName", ",", "s", ".", "Sum", "(", "nil", ")", ")", "\n", "vnames", "[", "k", "]", "=", "vname", "\n\n", "fmt", ".", "Fprintf", "(", "writer", ",", "\"", "\\n", "\"", ",", "vname", ",", "string", "(", "data", ")", ")", "\n", "}", "\n\n", "fmt", ".", "Fprintln", "(", "writer", ")", "\n", "}", "\n\n", "fmt", ".", "Fprintf", "(", "writer", ",", "\"", "\\n", "\"", ",", "variableName", ")", "\n", "fmt", ".", "Fprintf", "(", "writer", ",", "\"", "\"", ",", "variableName", ")", "\n\n", "if", "x", ".", "fsDirsMap", "==", "nil", "{", "x", ".", "fsDirsMap", "=", "make", "(", "map", "[", "string", "]", "[", "]", "string", ")", "\n", "}", "\n\n", "if", "x", ".", "fsFilesMap", "==", "nil", "{", "x", ".", "fsFilesMap", "=", "make", "(", "map", "[", "string", "]", "file", ")", "\n", "}", "\n\n", "dirmap", ":=", "make", "(", "map", "[", "string", "]", "[", "]", "string", ")", "\n\n", "for", "k", ",", "v", ":=", "range", "x", ".", "fsDirsMap", "{", "if", "kk", ",", "ok", ":=", "x", ".", "stripPrefix", "(", "k", ")", ";", "ok", "{", "if", "len", "(", "kk", ")", "==", "0", "{", "kk", "=", "\"", "\"", "\n", "}", "\n\n", "dirmap", "[", "kk", "]", "=", "v", "\n", "}", "\n", "}", "\n\n", "fmt", ".", "Fprintf", "(", "writer", ",", "\"", "\"", ",", "dirmap", ")", "\n", "fmt", ".", "Fprintf", "(", "writer", ",", "\"", "\\n", "\"", ")", "\n\n", "// Write files", "for", "k", ",", "v", ":=", "range", "x", ".", "fsFilesMap", "{", "kk", ",", "ok", ":=", "x", ".", "stripPrefix", "(", "k", ")", "\n\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n\n", "if", "len", "(", "kk", ")", "==", "0", "{", "kk", "=", "\"", "\"", "\n", "}", "\n\n", "mt", ":=", "v", ".", "info", ".", "ModTime", "(", ")", "\n\n", "var", "dt", "string", "\n\n", "if", "!", "v", ".", "info", ".", "IsDir", "(", ")", "{", "dt", "=", "\"", "\"", "+", "vnames", "[", "k", "]", "+", "\"", "\"", "\n", "}", "else", "{", "dt", "=", "\"", "\"", "\n", "}", "\n\n", "fmt", ".", "Fprintf", "(", "writer", ",", "\"", "\\t", "\\t", "\\n", "\"", ",", "kk", ")", "\n", "fmt", ".", "Fprintf", "(", "writer", ",", "\"", "\\t", "\\t", "\\t", "\\n", "\"", ",", "kk", ")", "\n", "fmt", ".", "Fprintf", "(", "writer", ",", "\"", "\\t", "\\t", "\\t", "\\n", "\"", ",", "v", ".", "info", ".", "Mode", "(", ")", ")", "\n", "fmt", ".", "Fprintf", "(", "writer", ",", "\"", "\\t", "\\t", "\\t", "\\n", "\"", ",", "mt", ".", "Unix", "(", ")", ",", "mt", ".", "UnixNano", "(", ")", ")", "\n", "fmt", ".", "Fprintf", "(", "writer", ",", "\"", "\\t", "\\t", "\\t", "\\n", "\"", ",", "dt", ")", "\n", "fmt", ".", "Fprintf", "(", "writer", ",", "\"", "\\t", "\\t", "\"", ")", "\n", "}", "\n\n", "fmt", ".", "Fprintln", "(", "writer", ",", "\"", "\\t", "\\\"", "\\\"", "\"", ")", "\n\n", "ret", ",", "err", ":=", "format", ".", "Source", "(", "writer", ".", "Bytes", "(", ")", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "wr", ".", "Write", "(", "ret", ")", "\n", "return", "nil", "\n", "}" ]
// Write the asset tree specified in the generator to the given writer. The // written asset tree is a valid, standalone go file with the assets // embedded into it.
[ "Write", "the", "asset", "tree", "specified", "in", "the", "generator", "to", "the", "given", "writer", ".", "The", "written", "asset", "tree", "is", "a", "valid", "standalone", "go", "file", "with", "the", "assets", "embedded", "into", "it", "." ]
4f4301a06e153ff90e17793577ab6bf79f8dc5c5
https://github.com/jessevdk/go-assets/blob/4f4301a06e153ff90e17793577ab6bf79f8dc5c5/generate.go#L170-L298
4
ttacon/libphonenumber
phonenumberutil.go
isViablePhoneNumber
func isViablePhoneNumber(number string) bool { if len(number) < MIN_LENGTH_FOR_NSN { return false } return VALID_PHONE_NUMBER_PATTERN.MatchString(number) }
go
func isViablePhoneNumber(number string) bool { if len(number) < MIN_LENGTH_FOR_NSN { return false } return VALID_PHONE_NUMBER_PATTERN.MatchString(number) }
[ "func", "isViablePhoneNumber", "(", "number", "string", ")", "bool", "{", "if", "len", "(", "number", ")", "<", "MIN_LENGTH_FOR_NSN", "{", "return", "false", "\n", "}", "\n", "return", "VALID_PHONE_NUMBER_PATTERN", ".", "MatchString", "(", "number", ")", "\n", "}" ]
// Checks to see if the string of characters could possibly be a phone // number at all. At the moment, checks to see that the string begins // with at least 2 digits, ignoring any punctuation commonly found in // phone numbers. This method does not require the number to be // normalized in advance - but does assume that leading non-number symbols // have been removed, such as by the method extractPossibleNumber. // @VisibleForTesting
[ "Checks", "to", "see", "if", "the", "string", "of", "characters", "could", "possibly", "be", "a", "phone", "number", "at", "all", ".", "At", "the", "moment", "checks", "to", "see", "that", "the", "string", "begins", "with", "at", "least", "2", "digits", "ignoring", "any", "punctuation", "commonly", "found", "in", "phone", "numbers", ".", "This", "method", "does", "not", "require", "the", "number", "to", "be", "normalized", "in", "advance", "-", "but", "does", "assume", "that", "leading", "non", "-", "number", "symbols", "have", "been", "removed", "such", "as", "by", "the", "method", "extractPossibleNumber", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L725-L730
5
ttacon/libphonenumber
phonenumberutil.go
GetCountryMobileToken
func GetCountryMobileToken(countryCallingCode int) string { if val, ok := MOBILE_TOKEN_MAPPINGS[countryCallingCode]; ok { return val } return "" }
go
func GetCountryMobileToken(countryCallingCode int) string { if val, ok := MOBILE_TOKEN_MAPPINGS[countryCallingCode]; ok { return val } return "" }
[ "func", "GetCountryMobileToken", "(", "countryCallingCode", "int", ")", "string", "{", "if", "val", ",", "ok", ":=", "MOBILE_TOKEN_MAPPINGS", "[", "countryCallingCode", "]", ";", "ok", "{", "return", "val", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]
// Returns the mobile token for the provided country calling code if it // has one, otherwise returns an empty string. A mobile token is a number // inserted before the area code when dialing a mobile number from that // country from abroad.
[ "Returns", "the", "mobile", "token", "for", "the", "provided", "country", "calling", "code", "if", "it", "has", "one", "otherwise", "returns", "an", "empty", "string", ".", "A", "mobile", "token", "is", "a", "number", "inserted", "before", "the", "area", "code", "when", "dialing", "a", "mobile", "number", "from", "that", "country", "from", "abroad", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L958-L963
6
ttacon/libphonenumber
phonenumberutil.go
normalizeHelper
func normalizeHelper(number string, normalizationReplacements map[rune]rune, removeNonMatches bool) string { var normalizedNumber = builder.NewBuilder(nil) for _, character := range number { newDigit, ok := normalizationReplacements[unicode.ToUpper(character)] if ok { normalizedNumber.WriteRune(newDigit) } else if !removeNonMatches { normalizedNumber.WriteRune(character) } // If neither of the above are true, we remove this character. } return normalizedNumber.String() }
go
func normalizeHelper(number string, normalizationReplacements map[rune]rune, removeNonMatches bool) string { var normalizedNumber = builder.NewBuilder(nil) for _, character := range number { newDigit, ok := normalizationReplacements[unicode.ToUpper(character)] if ok { normalizedNumber.WriteRune(newDigit) } else if !removeNonMatches { normalizedNumber.WriteRune(character) } // If neither of the above are true, we remove this character. } return normalizedNumber.String() }
[ "func", "normalizeHelper", "(", "number", "string", ",", "normalizationReplacements", "map", "[", "rune", "]", "rune", ",", "removeNonMatches", "bool", ")", "string", "{", "var", "normalizedNumber", "=", "builder", ".", "NewBuilder", "(", "nil", ")", "\n", "for", "_", ",", "character", ":=", "range", "number", "{", "newDigit", ",", "ok", ":=", "normalizationReplacements", "[", "unicode", ".", "ToUpper", "(", "character", ")", "]", "\n", "if", "ok", "{", "normalizedNumber", ".", "WriteRune", "(", "newDigit", ")", "\n", "}", "else", "if", "!", "removeNonMatches", "{", "normalizedNumber", ".", "WriteRune", "(", "character", ")", "\n", "}", "\n", "// If neither of the above are true, we remove this character.", "}", "\n", "return", "normalizedNumber", ".", "String", "(", ")", "\n", "}" ]
// Normalizes a string of characters representing a phone number by replacing // all characters found in the accompanying map with the values therein, // and stripping all other characters if removeNonMatches is true.
[ "Normalizes", "a", "string", "of", "characters", "representing", "a", "phone", "number", "by", "replacing", "all", "characters", "found", "in", "the", "accompanying", "map", "with", "the", "values", "therein", "and", "stripping", "all", "other", "characters", "if", "removeNonMatches", "is", "true", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L968-L983
7
ttacon/libphonenumber
phonenumberutil.go
isNumberGeographical
func isNumberGeographical(phoneNumber *PhoneNumber) bool { numberType := GetNumberType(phoneNumber) // TODO: Include mobile phone numbers from countries like Indonesia, // which has some mobile numbers that are geographical. return numberType == FIXED_LINE || numberType == FIXED_LINE_OR_MOBILE }
go
func isNumberGeographical(phoneNumber *PhoneNumber) bool { numberType := GetNumberType(phoneNumber) // TODO: Include mobile phone numbers from countries like Indonesia, // which has some mobile numbers that are geographical. return numberType == FIXED_LINE || numberType == FIXED_LINE_OR_MOBILE }
[ "func", "isNumberGeographical", "(", "phoneNumber", "*", "PhoneNumber", ")", "bool", "{", "numberType", ":=", "GetNumberType", "(", "phoneNumber", ")", "\n", "// TODO: Include mobile phone numbers from countries like Indonesia,", "// which has some mobile numbers that are geographical.", "return", "numberType", "==", "FIXED_LINE", "||", "numberType", "==", "FIXED_LINE_OR_MOBILE", "\n", "}" ]
// Tests whether a phone number has a geographical association. It checks // if the number is associated to a certain region in the country where it // belongs to. Note that this doesn't verify if the number is actually in use. // // A similar method is implemented as PhoneNumberOfflineGeocoder.canBeGeocoded, // which performs a looser check, since it only prevents cases where prefixes // overlap for geocodable and non-geocodable numbers. Also, if new phone // number types were added, we should check if this other method should be // updated too.
[ "Tests", "whether", "a", "phone", "number", "has", "a", "geographical", "association", ".", "It", "checks", "if", "the", "number", "is", "associated", "to", "a", "certain", "region", "in", "the", "country", "where", "it", "belongs", "to", ".", "Note", "that", "this", "doesn", "t", "verify", "if", "the", "number", "is", "actually", "in", "use", ".", "A", "similar", "method", "is", "implemented", "as", "PhoneNumberOfflineGeocoder", ".", "canBeGeocoded", "which", "performs", "a", "looser", "check", "since", "it", "only", "prevents", "cases", "where", "prefixes", "overlap", "for", "geocodable", "and", "non", "-", "geocodable", "numbers", ".", "Also", "if", "new", "phone", "number", "types", "were", "added", "we", "should", "check", "if", "this", "other", "method", "should", "be", "updated", "too", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1012-L1018
8
ttacon/libphonenumber
phonenumberutil.go
isValidRegionCode
func isValidRegionCode(regionCode string) bool { _, contains := readFromSupportedRegions(regionCode) return len(regionCode) != 0 && contains }
go
func isValidRegionCode(regionCode string) bool { _, contains := readFromSupportedRegions(regionCode) return len(regionCode) != 0 && contains }
[ "func", "isValidRegionCode", "(", "regionCode", "string", ")", "bool", "{", "_", ",", "contains", ":=", "readFromSupportedRegions", "(", "regionCode", ")", "\n", "return", "len", "(", "regionCode", ")", "!=", "0", "&&", "contains", "\n", "}" ]
// Helper function to check region code is not unknown or null.
[ "Helper", "function", "to", "check", "region", "code", "is", "not", "unknown", "or", "null", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1021-L1024
9
ttacon/libphonenumber
phonenumberutil.go
Format
func Format(number *PhoneNumber, numberFormat PhoneNumberFormat) string { if number.GetNationalNumber() == 0 && len(number.GetRawInput()) > 0 { // Unparseable numbers that kept their raw input just use that. // This is the only case where a number can be formatted as E164 // without a leading '+' symbol (but the original number wasn't // parseable anyway). // TODO: Consider removing the 'if' above so that unparseable // strings without raw input format to the empty string instead of "+00" rawInput := number.GetRawInput() if len(rawInput) > 0 { return rawInput } } var formattedNumber = builder.NewBuilder(nil) FormatWithBuf(number, numberFormat, formattedNumber) return formattedNumber.String() }
go
func Format(number *PhoneNumber, numberFormat PhoneNumberFormat) string { if number.GetNationalNumber() == 0 && len(number.GetRawInput()) > 0 { // Unparseable numbers that kept their raw input just use that. // This is the only case where a number can be formatted as E164 // without a leading '+' symbol (but the original number wasn't // parseable anyway). // TODO: Consider removing the 'if' above so that unparseable // strings without raw input format to the empty string instead of "+00" rawInput := number.GetRawInput() if len(rawInput) > 0 { return rawInput } } var formattedNumber = builder.NewBuilder(nil) FormatWithBuf(number, numberFormat, formattedNumber) return formattedNumber.String() }
[ "func", "Format", "(", "number", "*", "PhoneNumber", ",", "numberFormat", "PhoneNumberFormat", ")", "string", "{", "if", "number", ".", "GetNationalNumber", "(", ")", "==", "0", "&&", "len", "(", "number", ".", "GetRawInput", "(", ")", ")", ">", "0", "{", "// Unparseable numbers that kept their raw input just use that.", "// This is the only case where a number can be formatted as E164", "// without a leading '+' symbol (but the original number wasn't", "// parseable anyway).", "// TODO: Consider removing the 'if' above so that unparseable", "// strings without raw input format to the empty string instead of \"+00\"", "rawInput", ":=", "number", ".", "GetRawInput", "(", ")", "\n", "if", "len", "(", "rawInput", ")", ">", "0", "{", "return", "rawInput", "\n", "}", "\n", "}", "\n", "var", "formattedNumber", "=", "builder", ".", "NewBuilder", "(", "nil", ")", "\n", "FormatWithBuf", "(", "number", ",", "numberFormat", ",", "formattedNumber", ")", "\n", "return", "formattedNumber", ".", "String", "(", ")", "\n", "}" ]
// Formats a phone number in the specified format using default rules. Note // that this does not promise to produce a phone number that the user can // dial from where they are - although we do format in either 'national' or // 'international' format depending on what the client asks for, we do not // currently support a more abbreviated format, such as for users in the // same "area" who could potentially dial the number without area code. // Note that if the phone number has a country calling code of 0 or an // otherwise invalid country calling code, we cannot work out which // formatting rules to apply so we return the national significant number // with no formatting applied.
[ "Formats", "a", "phone", "number", "in", "the", "specified", "format", "using", "default", "rules", ".", "Note", "that", "this", "does", "not", "promise", "to", "produce", "a", "phone", "number", "that", "the", "user", "can", "dial", "from", "where", "they", "are", "-", "although", "we", "do", "format", "in", "either", "national", "or", "international", "format", "depending", "on", "what", "the", "client", "asks", "for", "we", "do", "not", "currently", "support", "a", "more", "abbreviated", "format", "such", "as", "for", "users", "in", "the", "same", "area", "who", "could", "potentially", "dial", "the", "number", "without", "area", "code", ".", "Note", "that", "if", "the", "phone", "number", "has", "a", "country", "calling", "code", "of", "0", "or", "an", "otherwise", "invalid", "country", "calling", "code", "we", "cannot", "work", "out", "which", "formatting", "rules", "to", "apply", "so", "we", "return", "the", "national", "significant", "number", "with", "no", "formatting", "applied", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1042-L1058
10
ttacon/libphonenumber
phonenumberutil.go
FormatByPattern
func FormatByPattern(number *PhoneNumber, numberFormat PhoneNumberFormat, userDefinedFormats []*NumberFormat) string { countryCallingCode := int(number.GetCountryCode()) nationalSignificantNumber := GetNationalSignificantNumber(number) if !hasValidCountryCallingCode(countryCallingCode) { return nationalSignificantNumber } // Note GetRegionCodeForCountryCode() is used because formatting // information for regions which share a country calling code is // contained by only one region for performance reasons. For example, // for NANPA regions it will be contained in the metadata for US. regionCode := GetRegionCodeForCountryCode(countryCallingCode) // Metadata cannot be null because the country calling code is valid metadata := getMetadataForRegionOrCallingCode(countryCallingCode, regionCode) formattedNumber := builder.NewBuilder(nil) formattingPattern := chooseFormattingPatternForNumber( userDefinedFormats, nationalSignificantNumber) if formattingPattern == nil { // If no pattern above is matched, we format the number as a whole. formattedNumber.WriteString(nationalSignificantNumber) } else { var numFormatCopy *NumberFormat // Before we do a replacement of the national prefix pattern // $NP with the national prefix, we need to copy the rule so // that subsequent replacements for different numbers have the // appropriate national prefix. proto.Merge(numFormatCopy, formattingPattern) nationalPrefixFormattingRule := formattingPattern.GetNationalPrefixFormattingRule() if len(nationalPrefixFormattingRule) > 0 { nationalPrefix := metadata.GetNationalPrefix() if len(nationalPrefix) > 0 { // Replace $NP with national prefix and $FG with the // first group ($1). nationalPrefixFormattingRule = NP_PATTERN.ReplaceAllString( nationalPrefixFormattingRule, nationalPrefix) nationalPrefixFormattingRule = FG_PATTERN.ReplaceAllString( nationalPrefixFormattingRule, "\\$1") numFormatCopy.NationalPrefixFormattingRule = &nationalPrefixFormattingRule } else { // We don't want to have a rule for how to format the // national prefix if there isn't one. numFormatCopy.NationalPrefixFormattingRule = nil } } formattedNumber.WriteString( formatNsnUsingPattern( nationalSignificantNumber, numFormatCopy, numberFormat)) } maybeAppendFormattedExtension(number, metadata, numberFormat, formattedNumber) prefixNumberWithCountryCallingCode(countryCallingCode, numberFormat, formattedNumber) return formattedNumber.String() }
go
func FormatByPattern(number *PhoneNumber, numberFormat PhoneNumberFormat, userDefinedFormats []*NumberFormat) string { countryCallingCode := int(number.GetCountryCode()) nationalSignificantNumber := GetNationalSignificantNumber(number) if !hasValidCountryCallingCode(countryCallingCode) { return nationalSignificantNumber } // Note GetRegionCodeForCountryCode() is used because formatting // information for regions which share a country calling code is // contained by only one region for performance reasons. For example, // for NANPA regions it will be contained in the metadata for US. regionCode := GetRegionCodeForCountryCode(countryCallingCode) // Metadata cannot be null because the country calling code is valid metadata := getMetadataForRegionOrCallingCode(countryCallingCode, regionCode) formattedNumber := builder.NewBuilder(nil) formattingPattern := chooseFormattingPatternForNumber( userDefinedFormats, nationalSignificantNumber) if formattingPattern == nil { // If no pattern above is matched, we format the number as a whole. formattedNumber.WriteString(nationalSignificantNumber) } else { var numFormatCopy *NumberFormat // Before we do a replacement of the national prefix pattern // $NP with the national prefix, we need to copy the rule so // that subsequent replacements for different numbers have the // appropriate national prefix. proto.Merge(numFormatCopy, formattingPattern) nationalPrefixFormattingRule := formattingPattern.GetNationalPrefixFormattingRule() if len(nationalPrefixFormattingRule) > 0 { nationalPrefix := metadata.GetNationalPrefix() if len(nationalPrefix) > 0 { // Replace $NP with national prefix and $FG with the // first group ($1). nationalPrefixFormattingRule = NP_PATTERN.ReplaceAllString( nationalPrefixFormattingRule, nationalPrefix) nationalPrefixFormattingRule = FG_PATTERN.ReplaceAllString( nationalPrefixFormattingRule, "\\$1") numFormatCopy.NationalPrefixFormattingRule = &nationalPrefixFormattingRule } else { // We don't want to have a rule for how to format the // national prefix if there isn't one. numFormatCopy.NationalPrefixFormattingRule = nil } } formattedNumber.WriteString( formatNsnUsingPattern( nationalSignificantNumber, numFormatCopy, numberFormat)) } maybeAppendFormattedExtension(number, metadata, numberFormat, formattedNumber) prefixNumberWithCountryCallingCode(countryCallingCode, numberFormat, formattedNumber) return formattedNumber.String() }
[ "func", "FormatByPattern", "(", "number", "*", "PhoneNumber", ",", "numberFormat", "PhoneNumberFormat", ",", "userDefinedFormats", "[", "]", "*", "NumberFormat", ")", "string", "{", "countryCallingCode", ":=", "int", "(", "number", ".", "GetCountryCode", "(", ")", ")", "\n", "nationalSignificantNumber", ":=", "GetNationalSignificantNumber", "(", "number", ")", "\n", "if", "!", "hasValidCountryCallingCode", "(", "countryCallingCode", ")", "{", "return", "nationalSignificantNumber", "\n", "}", "\n", "// Note GetRegionCodeForCountryCode() is used because formatting", "// information for regions which share a country calling code is", "// contained by only one region for performance reasons. For example,", "// for NANPA regions it will be contained in the metadata for US.", "regionCode", ":=", "GetRegionCodeForCountryCode", "(", "countryCallingCode", ")", "\n", "// Metadata cannot be null because the country calling code is valid", "metadata", ":=", "getMetadataForRegionOrCallingCode", "(", "countryCallingCode", ",", "regionCode", ")", "\n\n", "formattedNumber", ":=", "builder", ".", "NewBuilder", "(", "nil", ")", "\n\n", "formattingPattern", ":=", "chooseFormattingPatternForNumber", "(", "userDefinedFormats", ",", "nationalSignificantNumber", ")", "\n", "if", "formattingPattern", "==", "nil", "{", "// If no pattern above is matched, we format the number as a whole.", "formattedNumber", ".", "WriteString", "(", "nationalSignificantNumber", ")", "\n", "}", "else", "{", "var", "numFormatCopy", "*", "NumberFormat", "\n", "// Before we do a replacement of the national prefix pattern", "// $NP with the national prefix, we need to copy the rule so", "// that subsequent replacements for different numbers have the", "// appropriate national prefix.", "proto", ".", "Merge", "(", "numFormatCopy", ",", "formattingPattern", ")", "\n", "nationalPrefixFormattingRule", ":=", "formattingPattern", ".", "GetNationalPrefixFormattingRule", "(", ")", "\n", "if", "len", "(", "nationalPrefixFormattingRule", ")", ">", "0", "{", "nationalPrefix", ":=", "metadata", ".", "GetNationalPrefix", "(", ")", "\n", "if", "len", "(", "nationalPrefix", ")", ">", "0", "{", "// Replace $NP with national prefix and $FG with the", "// first group ($1).", "nationalPrefixFormattingRule", "=", "NP_PATTERN", ".", "ReplaceAllString", "(", "nationalPrefixFormattingRule", ",", "nationalPrefix", ")", "\n", "nationalPrefixFormattingRule", "=", "FG_PATTERN", ".", "ReplaceAllString", "(", "nationalPrefixFormattingRule", ",", "\"", "\\\\", "\"", ")", "\n", "numFormatCopy", ".", "NationalPrefixFormattingRule", "=", "&", "nationalPrefixFormattingRule", "\n", "}", "else", "{", "// We don't want to have a rule for how to format the", "// national prefix if there isn't one.", "numFormatCopy", ".", "NationalPrefixFormattingRule", "=", "nil", "\n", "}", "\n", "}", "\n", "formattedNumber", ".", "WriteString", "(", "formatNsnUsingPattern", "(", "nationalSignificantNumber", ",", "numFormatCopy", ",", "numberFormat", ")", ")", "\n", "}", "\n", "maybeAppendFormattedExtension", "(", "number", ",", "metadata", ",", "numberFormat", ",", "formattedNumber", ")", "\n", "prefixNumberWithCountryCallingCode", "(", "countryCallingCode", ",", "numberFormat", ",", "formattedNumber", ")", "\n", "return", "formattedNumber", ".", "String", "(", ")", "\n", "}" ]
// Formats a phone number in the specified format using client-defined // formatting rules. Note that if the phone number has a country calling // code of zero or an otherwise invalid country calling code, we cannot // work out things like whether there should be a national prefix applied, // or how to format extensions, so we return the national significant // number with no formatting applied.
[ "Formats", "a", "phone", "number", "in", "the", "specified", "format", "using", "client", "-", "defined", "formatting", "rules", ".", "Note", "that", "if", "the", "phone", "number", "has", "a", "country", "calling", "code", "of", "zero", "or", "an", "otherwise", "invalid", "country", "calling", "code", "we", "cannot", "work", "out", "things", "like", "whether", "there", "should", "be", "a", "national", "prefix", "applied", "or", "how", "to", "format", "extensions", "so", "we", "return", "the", "national", "significant", "number", "with", "no", "formatting", "applied", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1109-L1167
11
ttacon/libphonenumber
phonenumberutil.go
FormatNationalNumberWithCarrierCode
func FormatNationalNumberWithCarrierCode(number *PhoneNumber, carrierCode string) string { countryCallingCode := int(number.GetCountryCode()) nationalSignificantNumber := GetNationalSignificantNumber(number) if !hasValidCountryCallingCode(countryCallingCode) { return nationalSignificantNumber } // Note GetRegionCodeForCountryCode() is used because formatting // information for regions which share a country calling code is // contained by only one region for performance reasons. For // example, for NANPA regions it will be contained in the metadata for US. regionCode := GetRegionCodeForCountryCode(countryCallingCode) // Metadata cannot be null because the country calling code is valid. metadata := getMetadataForRegionOrCallingCode(countryCallingCode, regionCode) formattedNumber := builder.NewBuilder(nil) formattedNumber.WriteString( formatNsnWithCarrier( nationalSignificantNumber, metadata, NATIONAL, carrierCode)) maybeAppendFormattedExtension(number, metadata, NATIONAL, formattedNumber) prefixNumberWithCountryCallingCode( countryCallingCode, NATIONAL, formattedNumber) return formattedNumber.String() }
go
func FormatNationalNumberWithCarrierCode(number *PhoneNumber, carrierCode string) string { countryCallingCode := int(number.GetCountryCode()) nationalSignificantNumber := GetNationalSignificantNumber(number) if !hasValidCountryCallingCode(countryCallingCode) { return nationalSignificantNumber } // Note GetRegionCodeForCountryCode() is used because formatting // information for regions which share a country calling code is // contained by only one region for performance reasons. For // example, for NANPA regions it will be contained in the metadata for US. regionCode := GetRegionCodeForCountryCode(countryCallingCode) // Metadata cannot be null because the country calling code is valid. metadata := getMetadataForRegionOrCallingCode(countryCallingCode, regionCode) formattedNumber := builder.NewBuilder(nil) formattedNumber.WriteString( formatNsnWithCarrier( nationalSignificantNumber, metadata, NATIONAL, carrierCode)) maybeAppendFormattedExtension(number, metadata, NATIONAL, formattedNumber) prefixNumberWithCountryCallingCode( countryCallingCode, NATIONAL, formattedNumber) return formattedNumber.String() }
[ "func", "FormatNationalNumberWithCarrierCode", "(", "number", "*", "PhoneNumber", ",", "carrierCode", "string", ")", "string", "{", "countryCallingCode", ":=", "int", "(", "number", ".", "GetCountryCode", "(", ")", ")", "\n", "nationalSignificantNumber", ":=", "GetNationalSignificantNumber", "(", "number", ")", "\n", "if", "!", "hasValidCountryCallingCode", "(", "countryCallingCode", ")", "{", "return", "nationalSignificantNumber", "\n", "}", "\n", "// Note GetRegionCodeForCountryCode() is used because formatting", "// information for regions which share a country calling code is", "// contained by only one region for performance reasons. For", "// example, for NANPA regions it will be contained in the metadata for US.", "regionCode", ":=", "GetRegionCodeForCountryCode", "(", "countryCallingCode", ")", "\n", "// Metadata cannot be null because the country calling code is valid.", "metadata", ":=", "getMetadataForRegionOrCallingCode", "(", "countryCallingCode", ",", "regionCode", ")", "\n\n", "formattedNumber", ":=", "builder", ".", "NewBuilder", "(", "nil", ")", "\n", "formattedNumber", ".", "WriteString", "(", "formatNsnWithCarrier", "(", "nationalSignificantNumber", ",", "metadata", ",", "NATIONAL", ",", "carrierCode", ")", ")", "\n", "maybeAppendFormattedExtension", "(", "number", ",", "metadata", ",", "NATIONAL", ",", "formattedNumber", ")", "\n", "prefixNumberWithCountryCallingCode", "(", "countryCallingCode", ",", "NATIONAL", ",", "formattedNumber", ")", "\n", "return", "formattedNumber", ".", "String", "(", ")", "\n", "}" ]
// Formats a phone number in national format for dialing using the carrier // as specified in the carrierCode. The carrierCode will always be used // regardless of whether the phone number already has a preferred domestic // carrier code stored. If carrierCode contains an empty string, returns // the number in national format without any carrier code.
[ "Formats", "a", "phone", "number", "in", "national", "format", "for", "dialing", "using", "the", "carrier", "as", "specified", "in", "the", "carrierCode", ".", "The", "carrierCode", "will", "always", "be", "used", "regardless", "of", "whether", "the", "phone", "number", "already", "has", "a", "preferred", "domestic", "carrier", "code", "stored", ".", "If", "carrierCode", "contains", "an", "empty", "string", "returns", "the", "number", "in", "national", "format", "without", "any", "carrier", "code", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1174-L1201
12
ttacon/libphonenumber
phonenumberutil.go
FormatNationalNumberWithPreferredCarrierCode
func FormatNationalNumberWithPreferredCarrierCode( number *PhoneNumber, fallbackCarrierCode string) string { pref := number.GetPreferredDomesticCarrierCode() if number.GetPreferredDomesticCarrierCode() == "" { pref = fallbackCarrierCode } return FormatNationalNumberWithCarrierCode(number, pref) }
go
func FormatNationalNumberWithPreferredCarrierCode( number *PhoneNumber, fallbackCarrierCode string) string { pref := number.GetPreferredDomesticCarrierCode() if number.GetPreferredDomesticCarrierCode() == "" { pref = fallbackCarrierCode } return FormatNationalNumberWithCarrierCode(number, pref) }
[ "func", "FormatNationalNumberWithPreferredCarrierCode", "(", "number", "*", "PhoneNumber", ",", "fallbackCarrierCode", "string", ")", "string", "{", "pref", ":=", "number", ".", "GetPreferredDomesticCarrierCode", "(", ")", "\n", "if", "number", ".", "GetPreferredDomesticCarrierCode", "(", ")", "==", "\"", "\"", "{", "pref", "=", "fallbackCarrierCode", "\n", "}", "\n", "return", "FormatNationalNumberWithCarrierCode", "(", "number", ",", "pref", ")", "\n", "}" ]
// Formats a phone number in national format for dialing using the carrier // as specified in the preferredDomesticCarrierCode field of the PhoneNumber // object passed in. If that is missing, use the fallbackCarrierCode passed // in instead. If there is no preferredDomesticCarrierCode, and the // fallbackCarrierCode contains an empty string, return the number in // national format without any carrier code. // // Use formatNationalNumberWithCarrierCode instead if the carrier code // passed in should take precedence over the number's // preferredDomesticCarrierCode when formatting.
[ "Formats", "a", "phone", "number", "in", "national", "format", "for", "dialing", "using", "the", "carrier", "as", "specified", "in", "the", "preferredDomesticCarrierCode", "field", "of", "the", "PhoneNumber", "object", "passed", "in", ".", "If", "that", "is", "missing", "use", "the", "fallbackCarrierCode", "passed", "in", "instead", ".", "If", "there", "is", "no", "preferredDomesticCarrierCode", "and", "the", "fallbackCarrierCode", "contains", "an", "empty", "string", "return", "the", "number", "in", "national", "format", "without", "any", "carrier", "code", ".", "Use", "formatNationalNumberWithCarrierCode", "instead", "if", "the", "carrier", "code", "passed", "in", "should", "take", "precedence", "over", "the", "number", "s", "preferredDomesticCarrierCode", "when", "formatting", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1221-L1230
13
ttacon/libphonenumber
phonenumberutil.go
FormatInOriginalFormat
func FormatInOriginalFormat(number *PhoneNumber, regionCallingFrom string) string { rawInput := number.GetRawInput() if len(rawInput) == 0 && (hasUnexpectedItalianLeadingZero(number) || !hasFormattingPatternForNumber(number)) { // We check if we have the formatting pattern because without that, we might format the number // as a group without national prefix. return rawInput } if number.GetCountryCodeSource() == 0 { return Format(number, NATIONAL) } var formattedNumber string switch number.GetCountryCodeSource() { case PhoneNumber_FROM_NUMBER_WITH_PLUS_SIGN: formattedNumber = Format(number, INTERNATIONAL) case PhoneNumber_FROM_NUMBER_WITH_IDD: formattedNumber = FormatOutOfCountryCallingNumber(number, regionCallingFrom) case PhoneNumber_FROM_NUMBER_WITHOUT_PLUS_SIGN: formattedNumber = Format(number, INTERNATIONAL)[1:] case PhoneNumber_FROM_DEFAULT_COUNTRY: // Fall-through to default case. fallthrough default: regionCode := GetRegionCodeForCountryCode(int(number.GetCountryCode())) // We strip non-digits from the NDD here, and from the raw // input later, so that we can compare them easily. nationalPrefix := GetNddPrefixForRegion( regionCode, true /* strip non-digits */) nationalFormat := Format(number, NATIONAL) if len(nationalPrefix) == 0 { // If the region doesn't have a national prefix at all, // we can safely return the national format without worrying // about a national prefix being added. formattedNumber = nationalFormat break } // Otherwise, we check if the original number was entered with // a national prefix. if rawInputContainsNationalPrefix(rawInput, nationalPrefix, regionCode) { // If so, we can safely return the national format. formattedNumber = nationalFormat } // Metadata cannot be null here because GetNddPrefixForRegion() // (above) returns null if there is no metadata for the region. metadata := getMetadataForRegion(regionCode) nationalNumber := GetNationalSignificantNumber(number) formatRule := chooseFormattingPatternForNumber(metadata.GetNumberFormat(), nationalNumber) // The format rule could still be null here if the national // number was 0 and there was no raw input (this should not // be possible for numbers generated by the phonenumber library // as they would also not have a country calling code and we // would have exited earlier). if formatRule == nil { formattedNumber = nationalFormat break } // When the format we apply to this number doesn't contain // national prefix, we can just return the national format. // TODO: Refactor the code below with the code in // isNationalPrefixPresentIfRequired. candidateNationalPrefixRule := formatRule.GetNationalPrefixFormattingRule() // We assume that the first-group symbol will never be _before_ // the national prefix. indexOfFirstGroup := strings.Index(candidateNationalPrefixRule, "$1") if indexOfFirstGroup <= 0 { formattedNumber = nationalFormat break } candidateNationalPrefixRule = candidateNationalPrefixRule[0:indexOfFirstGroup] candidateNationalPrefixRule = NormalizeDigitsOnly(candidateNationalPrefixRule) if len(candidateNationalPrefixRule) == 0 { // National prefix not used when formatting this number. formattedNumber = nationalFormat break } // Otherwise, we need to remove the national prefix from our output. var numFormatCopy *NumberFormat proto.Merge(numFormatCopy, formatRule) numFormatCopy.NationalPrefixFormattingRule = nil var numberFormats = []*NumberFormat{numFormatCopy} formattedNumber = FormatByPattern(number, NATIONAL, numberFormats) break } rawInput = number.GetRawInput() // If no digit is inserted/removed/modified as a result of our // formatting, we return the formatted phone number; otherwise we // return the raw input the user entered. if len(formattedNumber) != 0 && len(rawInput) > 0 { normalizedFormattedNumber := normalizeDiallableCharsOnly(formattedNumber) normalizedRawInput := normalizeDiallableCharsOnly(rawInput) if normalizedFormattedNumber != normalizedRawInput { formattedNumber = rawInput } } return formattedNumber }
go
func FormatInOriginalFormat(number *PhoneNumber, regionCallingFrom string) string { rawInput := number.GetRawInput() if len(rawInput) == 0 && (hasUnexpectedItalianLeadingZero(number) || !hasFormattingPatternForNumber(number)) { // We check if we have the formatting pattern because without that, we might format the number // as a group without national prefix. return rawInput } if number.GetCountryCodeSource() == 0 { return Format(number, NATIONAL) } var formattedNumber string switch number.GetCountryCodeSource() { case PhoneNumber_FROM_NUMBER_WITH_PLUS_SIGN: formattedNumber = Format(number, INTERNATIONAL) case PhoneNumber_FROM_NUMBER_WITH_IDD: formattedNumber = FormatOutOfCountryCallingNumber(number, regionCallingFrom) case PhoneNumber_FROM_NUMBER_WITHOUT_PLUS_SIGN: formattedNumber = Format(number, INTERNATIONAL)[1:] case PhoneNumber_FROM_DEFAULT_COUNTRY: // Fall-through to default case. fallthrough default: regionCode := GetRegionCodeForCountryCode(int(number.GetCountryCode())) // We strip non-digits from the NDD here, and from the raw // input later, so that we can compare them easily. nationalPrefix := GetNddPrefixForRegion( regionCode, true /* strip non-digits */) nationalFormat := Format(number, NATIONAL) if len(nationalPrefix) == 0 { // If the region doesn't have a national prefix at all, // we can safely return the national format without worrying // about a national prefix being added. formattedNumber = nationalFormat break } // Otherwise, we check if the original number was entered with // a national prefix. if rawInputContainsNationalPrefix(rawInput, nationalPrefix, regionCode) { // If so, we can safely return the national format. formattedNumber = nationalFormat } // Metadata cannot be null here because GetNddPrefixForRegion() // (above) returns null if there is no metadata for the region. metadata := getMetadataForRegion(regionCode) nationalNumber := GetNationalSignificantNumber(number) formatRule := chooseFormattingPatternForNumber(metadata.GetNumberFormat(), nationalNumber) // The format rule could still be null here if the national // number was 0 and there was no raw input (this should not // be possible for numbers generated by the phonenumber library // as they would also not have a country calling code and we // would have exited earlier). if formatRule == nil { formattedNumber = nationalFormat break } // When the format we apply to this number doesn't contain // national prefix, we can just return the national format. // TODO: Refactor the code below with the code in // isNationalPrefixPresentIfRequired. candidateNationalPrefixRule := formatRule.GetNationalPrefixFormattingRule() // We assume that the first-group symbol will never be _before_ // the national prefix. indexOfFirstGroup := strings.Index(candidateNationalPrefixRule, "$1") if indexOfFirstGroup <= 0 { formattedNumber = nationalFormat break } candidateNationalPrefixRule = candidateNationalPrefixRule[0:indexOfFirstGroup] candidateNationalPrefixRule = NormalizeDigitsOnly(candidateNationalPrefixRule) if len(candidateNationalPrefixRule) == 0 { // National prefix not used when formatting this number. formattedNumber = nationalFormat break } // Otherwise, we need to remove the national prefix from our output. var numFormatCopy *NumberFormat proto.Merge(numFormatCopy, formatRule) numFormatCopy.NationalPrefixFormattingRule = nil var numberFormats = []*NumberFormat{numFormatCopy} formattedNumber = FormatByPattern(number, NATIONAL, numberFormats) break } rawInput = number.GetRawInput() // If no digit is inserted/removed/modified as a result of our // formatting, we return the formatted phone number; otherwise we // return the raw input the user entered. if len(formattedNumber) != 0 && len(rawInput) > 0 { normalizedFormattedNumber := normalizeDiallableCharsOnly(formattedNumber) normalizedRawInput := normalizeDiallableCharsOnly(rawInput) if normalizedFormattedNumber != normalizedRawInput { formattedNumber = rawInput } } return formattedNumber }
[ "func", "FormatInOriginalFormat", "(", "number", "*", "PhoneNumber", ",", "regionCallingFrom", "string", ")", "string", "{", "rawInput", ":=", "number", ".", "GetRawInput", "(", ")", "\n", "if", "len", "(", "rawInput", ")", "==", "0", "&&", "(", "hasUnexpectedItalianLeadingZero", "(", "number", ")", "||", "!", "hasFormattingPatternForNumber", "(", "number", ")", ")", "{", "// We check if we have the formatting pattern because without that, we might format the number", "// as a group without national prefix.", "return", "rawInput", "\n", "}", "\n", "if", "number", ".", "GetCountryCodeSource", "(", ")", "==", "0", "{", "return", "Format", "(", "number", ",", "NATIONAL", ")", "\n", "}", "\n", "var", "formattedNumber", "string", "\n", "switch", "number", ".", "GetCountryCodeSource", "(", ")", "{", "case", "PhoneNumber_FROM_NUMBER_WITH_PLUS_SIGN", ":", "formattedNumber", "=", "Format", "(", "number", ",", "INTERNATIONAL", ")", "\n", "case", "PhoneNumber_FROM_NUMBER_WITH_IDD", ":", "formattedNumber", "=", "FormatOutOfCountryCallingNumber", "(", "number", ",", "regionCallingFrom", ")", "\n", "case", "PhoneNumber_FROM_NUMBER_WITHOUT_PLUS_SIGN", ":", "formattedNumber", "=", "Format", "(", "number", ",", "INTERNATIONAL", ")", "[", "1", ":", "]", "\n", "case", "PhoneNumber_FROM_DEFAULT_COUNTRY", ":", "// Fall-through to default case.", "fallthrough", "\n", "default", ":", "regionCode", ":=", "GetRegionCodeForCountryCode", "(", "int", "(", "number", ".", "GetCountryCode", "(", ")", ")", ")", "\n", "// We strip non-digits from the NDD here, and from the raw", "// input later, so that we can compare them easily.", "nationalPrefix", ":=", "GetNddPrefixForRegion", "(", "regionCode", ",", "true", "/* strip non-digits */", ")", "\n", "nationalFormat", ":=", "Format", "(", "number", ",", "NATIONAL", ")", "\n", "if", "len", "(", "nationalPrefix", ")", "==", "0", "{", "// If the region doesn't have a national prefix at all,", "// we can safely return the national format without worrying", "// about a national prefix being added.", "formattedNumber", "=", "nationalFormat", "\n", "break", "\n", "}", "\n", "// Otherwise, we check if the original number was entered with", "// a national prefix.", "if", "rawInputContainsNationalPrefix", "(", "rawInput", ",", "nationalPrefix", ",", "regionCode", ")", "{", "// If so, we can safely return the national format.", "formattedNumber", "=", "nationalFormat", "\n", "}", "\n", "// Metadata cannot be null here because GetNddPrefixForRegion()", "// (above) returns null if there is no metadata for the region.", "metadata", ":=", "getMetadataForRegion", "(", "regionCode", ")", "\n", "nationalNumber", ":=", "GetNationalSignificantNumber", "(", "number", ")", "\n", "formatRule", ":=", "chooseFormattingPatternForNumber", "(", "metadata", ".", "GetNumberFormat", "(", ")", ",", "nationalNumber", ")", "\n", "// The format rule could still be null here if the national", "// number was 0 and there was no raw input (this should not", "// be possible for numbers generated by the phonenumber library", "// as they would also not have a country calling code and we", "// would have exited earlier).", "if", "formatRule", "==", "nil", "{", "formattedNumber", "=", "nationalFormat", "\n", "break", "\n", "}", "\n", "// When the format we apply to this number doesn't contain", "// national prefix, we can just return the national format.", "// TODO: Refactor the code below with the code in", "// isNationalPrefixPresentIfRequired.", "candidateNationalPrefixRule", ":=", "formatRule", ".", "GetNationalPrefixFormattingRule", "(", ")", "\n", "// We assume that the first-group symbol will never be _before_", "// the national prefix.", "indexOfFirstGroup", ":=", "strings", ".", "Index", "(", "candidateNationalPrefixRule", ",", "\"", "\"", ")", "\n", "if", "indexOfFirstGroup", "<=", "0", "{", "formattedNumber", "=", "nationalFormat", "\n", "break", "\n", "}", "\n", "candidateNationalPrefixRule", "=", "candidateNationalPrefixRule", "[", "0", ":", "indexOfFirstGroup", "]", "\n", "candidateNationalPrefixRule", "=", "NormalizeDigitsOnly", "(", "candidateNationalPrefixRule", ")", "\n", "if", "len", "(", "candidateNationalPrefixRule", ")", "==", "0", "{", "// National prefix not used when formatting this number.", "formattedNumber", "=", "nationalFormat", "\n", "break", "\n", "}", "\n", "// Otherwise, we need to remove the national prefix from our output.", "var", "numFormatCopy", "*", "NumberFormat", "\n", "proto", ".", "Merge", "(", "numFormatCopy", ",", "formatRule", ")", "\n", "numFormatCopy", ".", "NationalPrefixFormattingRule", "=", "nil", "\n", "var", "numberFormats", "=", "[", "]", "*", "NumberFormat", "{", "numFormatCopy", "}", "\n", "formattedNumber", "=", "FormatByPattern", "(", "number", ",", "NATIONAL", ",", "numberFormats", ")", "\n", "break", "\n", "}", "\n", "rawInput", "=", "number", ".", "GetRawInput", "(", ")", "\n", "// If no digit is inserted/removed/modified as a result of our", "// formatting, we return the formatted phone number; otherwise we", "// return the raw input the user entered.", "if", "len", "(", "formattedNumber", ")", "!=", "0", "&&", "len", "(", "rawInput", ")", ">", "0", "{", "normalizedFormattedNumber", ":=", "normalizeDiallableCharsOnly", "(", "formattedNumber", ")", "\n", "normalizedRawInput", ":=", "normalizeDiallableCharsOnly", "(", "rawInput", ")", "\n", "if", "normalizedFormattedNumber", "!=", "normalizedRawInput", "{", "formattedNumber", "=", "rawInput", "\n", "}", "\n", "}", "\n", "return", "formattedNumber", "\n", "}" ]
// Formats a phone number using the original phone number format that the // number is parsed from. The original format is embedded in the // country_code_source field of the PhoneNumber object passed in. If such // information is missing, the number will be formatted into the NATIONAL // format by default. When the number contains a leading zero and this is // unexpected for this country, or we don't have a formatting pattern for // the number, the method returns the raw input when it is available. // // Note this method guarantees no digit will be inserted, removed or // modified as a result of formatting.
[ "Formats", "a", "phone", "number", "using", "the", "original", "phone", "number", "format", "that", "the", "number", "is", "parsed", "from", ".", "The", "original", "format", "is", "embedded", "in", "the", "country_code_source", "field", "of", "the", "PhoneNumber", "object", "passed", "in", ".", "If", "such", "information", "is", "missing", "the", "number", "will", "be", "formatted", "into", "the", "NATIONAL", "format", "by", "default", ".", "When", "the", "number", "contains", "a", "leading", "zero", "and", "this", "is", "unexpected", "for", "this", "country", "or", "we", "don", "t", "have", "a", "formatting", "pattern", "for", "the", "number", "the", "method", "returns", "the", "raw", "input", "when", "it", "is", "available", ".", "Note", "this", "method", "guarantees", "no", "digit", "will", "be", "inserted", "removed", "or", "modified", "as", "a", "result", "of", "formatting", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1444-L1542
14
ttacon/libphonenumber
phonenumberutil.go
rawInputContainsNationalPrefix
func rawInputContainsNationalPrefix(rawInput, nationalPrefix, regionCode string) bool { normalizedNationalNumber := NormalizeDigitsOnly(rawInput) if strings.HasPrefix(normalizedNationalNumber, nationalPrefix) { // Some Japanese numbers (e.g. 00777123) might be mistaken to // contain the national prefix when written without it // (e.g. 0777123) if we just do prefix matching. To tackle that, // we check the validity of the number if the assumed national // prefix is removed (777123 won't be valid in Japan). num, err := Parse(normalizedNationalNumber[len(nationalPrefix):], regionCode) if err != nil { return false } return IsValidNumber(num) } return false }
go
func rawInputContainsNationalPrefix(rawInput, nationalPrefix, regionCode string) bool { normalizedNationalNumber := NormalizeDigitsOnly(rawInput) if strings.HasPrefix(normalizedNationalNumber, nationalPrefix) { // Some Japanese numbers (e.g. 00777123) might be mistaken to // contain the national prefix when written without it // (e.g. 0777123) if we just do prefix matching. To tackle that, // we check the validity of the number if the assumed national // prefix is removed (777123 won't be valid in Japan). num, err := Parse(normalizedNationalNumber[len(nationalPrefix):], regionCode) if err != nil { return false } return IsValidNumber(num) } return false }
[ "func", "rawInputContainsNationalPrefix", "(", "rawInput", ",", "nationalPrefix", ",", "regionCode", "string", ")", "bool", "{", "normalizedNationalNumber", ":=", "NormalizeDigitsOnly", "(", "rawInput", ")", "\n", "if", "strings", ".", "HasPrefix", "(", "normalizedNationalNumber", ",", "nationalPrefix", ")", "{", "// Some Japanese numbers (e.g. 00777123) might be mistaken to", "// contain the national prefix when written without it", "// (e.g. 0777123) if we just do prefix matching. To tackle that,", "// we check the validity of the number if the assumed national", "// prefix is removed (777123 won't be valid in Japan).", "num", ",", "err", ":=", "Parse", "(", "normalizedNationalNumber", "[", "len", "(", "nationalPrefix", ")", ":", "]", ",", "regionCode", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "return", "IsValidNumber", "(", "num", ")", "\n\n", "}", "\n", "return", "false", "\n", "}" ]
// Check if rawInput, which is assumed to be in the national format, has // a national prefix. The national prefix is assumed to be in digits-only // form.
[ "Check", "if", "rawInput", "which", "is", "assumed", "to", "be", "in", "the", "national", "format", "has", "a", "national", "prefix", ".", "The", "national", "prefix", "is", "assumed", "to", "be", "in", "digits", "-", "only", "form", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1547-L1563
15
ttacon/libphonenumber
phonenumberutil.go
hasUnexpectedItalianLeadingZero
func hasUnexpectedItalianLeadingZero(number *PhoneNumber) bool { return number.GetItalianLeadingZero() && !isLeadingZeroPossible(int(number.GetCountryCode())) }
go
func hasUnexpectedItalianLeadingZero(number *PhoneNumber) bool { return number.GetItalianLeadingZero() && !isLeadingZeroPossible(int(number.GetCountryCode())) }
[ "func", "hasUnexpectedItalianLeadingZero", "(", "number", "*", "PhoneNumber", ")", "bool", "{", "return", "number", ".", "GetItalianLeadingZero", "(", ")", "&&", "!", "isLeadingZeroPossible", "(", "int", "(", "number", ".", "GetCountryCode", "(", ")", ")", ")", "\n", "}" ]
// Returns true if a number is from a region whose national significant // number couldn't contain a leading zero, but has the italian_leading_zero // field set to true.
[ "Returns", "true", "if", "a", "number", "is", "from", "a", "region", "whose", "national", "significant", "number", "couldn", "t", "contain", "a", "leading", "zero", "but", "has", "the", "italian_leading_zero", "field", "set", "to", "true", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1568-L1571
16
ttacon/libphonenumber
phonenumberutil.go
GetNationalSignificantNumber
func GetNationalSignificantNumber(number *PhoneNumber) string { // If leading zero(s) have been set, we prefix this now. Note this // is not a national prefix. nationalNumber := builder.NewBuilder(nil) if number.GetItalianLeadingZero() { zeros := make([]byte, number.GetNumberOfLeadingZeros()) for i := range zeros { zeros[i] = '0' } nationalNumber.Write(zeros) } asStr := strconv.FormatUint(number.GetNationalNumber(), 10) nationalNumber.WriteString(asStr) return nationalNumber.String() }
go
func GetNationalSignificantNumber(number *PhoneNumber) string { // If leading zero(s) have been set, we prefix this now. Note this // is not a national prefix. nationalNumber := builder.NewBuilder(nil) if number.GetItalianLeadingZero() { zeros := make([]byte, number.GetNumberOfLeadingZeros()) for i := range zeros { zeros[i] = '0' } nationalNumber.Write(zeros) } asStr := strconv.FormatUint(number.GetNationalNumber(), 10) nationalNumber.WriteString(asStr) return nationalNumber.String() }
[ "func", "GetNationalSignificantNumber", "(", "number", "*", "PhoneNumber", ")", "string", "{", "// If leading zero(s) have been set, we prefix this now. Note this", "// is not a national prefix.", "nationalNumber", ":=", "builder", ".", "NewBuilder", "(", "nil", ")", "\n", "if", "number", ".", "GetItalianLeadingZero", "(", ")", "{", "zeros", ":=", "make", "(", "[", "]", "byte", ",", "number", ".", "GetNumberOfLeadingZeros", "(", ")", ")", "\n", "for", "i", ":=", "range", "zeros", "{", "zeros", "[", "i", "]", "=", "'0'", "\n", "}", "\n", "nationalNumber", ".", "Write", "(", "zeros", ")", "\n", "}", "\n", "asStr", ":=", "strconv", ".", "FormatUint", "(", "number", ".", "GetNationalNumber", "(", ")", ",", "10", ")", "\n", "nationalNumber", ".", "WriteString", "(", "asStr", ")", "\n\n", "return", "nationalNumber", ".", "String", "(", ")", "\n", "}" ]
// Gets the national significant number of the a phone number. Note a // national significant number doesn't contain a national prefix or // any formatting.
[ "Gets", "the", "national", "significant", "number", "of", "the", "a", "phone", "number", ".", "Note", "a", "national", "significant", "number", "doesn", "t", "contain", "a", "national", "prefix", "or", "any", "formatting", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1718-L1733
17
ttacon/libphonenumber
phonenumberutil.go
prefixNumberWithCountryCallingCode
func prefixNumberWithCountryCallingCode( countryCallingCode int, numberFormat PhoneNumberFormat, formattedNumber *builder.Builder) { // TODO(ttacon): add some sort of BulkWrite builder to builder.Builder // also that name isn't too awesome...:) newBuf := builder.NewBuilder(nil) switch numberFormat { case E164: newBuf.WriteString(string(PLUS_SIGN)) newBuf.Write(strconv.AppendInt([]byte{}, int64(countryCallingCode), 10)) newBuf.Write(formattedNumber.Bytes()) case INTERNATIONAL: newBuf.WriteString(string(PLUS_SIGN)) newBuf.Write(strconv.AppendInt([]byte{}, int64(countryCallingCode), 10)) newBuf.WriteString(" ") newBuf.Write(formattedNumber.Bytes()) case RFC3966: newBuf.WriteString(RFC3966_PREFIX) newBuf.WriteString(string(PLUS_SIGN)) newBuf.Write(strconv.AppendInt([]byte{}, int64(countryCallingCode), 10)) newBuf.WriteString("-") newBuf.Write(formattedNumber.Bytes()) case NATIONAL: fallthrough default: newBuf.Write(formattedNumber.Bytes()) } formattedNumber.ResetWith(newBuf.Bytes()) }
go
func prefixNumberWithCountryCallingCode( countryCallingCode int, numberFormat PhoneNumberFormat, formattedNumber *builder.Builder) { // TODO(ttacon): add some sort of BulkWrite builder to builder.Builder // also that name isn't too awesome...:) newBuf := builder.NewBuilder(nil) switch numberFormat { case E164: newBuf.WriteString(string(PLUS_SIGN)) newBuf.Write(strconv.AppendInt([]byte{}, int64(countryCallingCode), 10)) newBuf.Write(formattedNumber.Bytes()) case INTERNATIONAL: newBuf.WriteString(string(PLUS_SIGN)) newBuf.Write(strconv.AppendInt([]byte{}, int64(countryCallingCode), 10)) newBuf.WriteString(" ") newBuf.Write(formattedNumber.Bytes()) case RFC3966: newBuf.WriteString(RFC3966_PREFIX) newBuf.WriteString(string(PLUS_SIGN)) newBuf.Write(strconv.AppendInt([]byte{}, int64(countryCallingCode), 10)) newBuf.WriteString("-") newBuf.Write(formattedNumber.Bytes()) case NATIONAL: fallthrough default: newBuf.Write(formattedNumber.Bytes()) } formattedNumber.ResetWith(newBuf.Bytes()) }
[ "func", "prefixNumberWithCountryCallingCode", "(", "countryCallingCode", "int", ",", "numberFormat", "PhoneNumberFormat", ",", "formattedNumber", "*", "builder", ".", "Builder", ")", "{", "// TODO(ttacon): add some sort of BulkWrite builder to builder.Builder", "// also that name isn't too awesome...:)", "newBuf", ":=", "builder", ".", "NewBuilder", "(", "nil", ")", "\n", "switch", "numberFormat", "{", "case", "E164", ":", "newBuf", ".", "WriteString", "(", "string", "(", "PLUS_SIGN", ")", ")", "\n", "newBuf", ".", "Write", "(", "strconv", ".", "AppendInt", "(", "[", "]", "byte", "{", "}", ",", "int64", "(", "countryCallingCode", ")", ",", "10", ")", ")", "\n", "newBuf", ".", "Write", "(", "formattedNumber", ".", "Bytes", "(", ")", ")", "\n", "case", "INTERNATIONAL", ":", "newBuf", ".", "WriteString", "(", "string", "(", "PLUS_SIGN", ")", ")", "\n", "newBuf", ".", "Write", "(", "strconv", ".", "AppendInt", "(", "[", "]", "byte", "{", "}", ",", "int64", "(", "countryCallingCode", ")", ",", "10", ")", ")", "\n", "newBuf", ".", "WriteString", "(", "\"", "\"", ")", "\n", "newBuf", ".", "Write", "(", "formattedNumber", ".", "Bytes", "(", ")", ")", "\n", "case", "RFC3966", ":", "newBuf", ".", "WriteString", "(", "RFC3966_PREFIX", ")", "\n", "newBuf", ".", "WriteString", "(", "string", "(", "PLUS_SIGN", ")", ")", "\n", "newBuf", ".", "Write", "(", "strconv", ".", "AppendInt", "(", "[", "]", "byte", "{", "}", ",", "int64", "(", "countryCallingCode", ")", ",", "10", ")", ")", "\n", "newBuf", ".", "WriteString", "(", "\"", "\"", ")", "\n", "newBuf", ".", "Write", "(", "formattedNumber", ".", "Bytes", "(", ")", ")", "\n", "case", "NATIONAL", ":", "fallthrough", "\n", "default", ":", "newBuf", ".", "Write", "(", "formattedNumber", ".", "Bytes", "(", ")", ")", "\n", "}", "\n", "formattedNumber", ".", "ResetWith", "(", "newBuf", ".", "Bytes", "(", ")", ")", "\n", "}" ]
// A helper function that is used by format and formatByPattern.
[ "A", "helper", "function", "that", "is", "used", "by", "format", "and", "formatByPattern", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1736-L1766
18
ttacon/libphonenumber
phonenumberutil.go
formatNsn
func formatNsn( number string, metadata *PhoneMetadata, numberFormat PhoneNumberFormat) string { return formatNsnWithCarrier(number, metadata, numberFormat, "") }
go
func formatNsn( number string, metadata *PhoneMetadata, numberFormat PhoneNumberFormat) string { return formatNsnWithCarrier(number, metadata, numberFormat, "") }
[ "func", "formatNsn", "(", "number", "string", ",", "metadata", "*", "PhoneMetadata", ",", "numberFormat", "PhoneNumberFormat", ")", "string", "{", "return", "formatNsnWithCarrier", "(", "number", ",", "metadata", ",", "numberFormat", ",", "\"", "\"", ")", "\n", "}" ]
// Simple wrapper of formatNsn for the common case of no carrier code.
[ "Simple", "wrapper", "of", "formatNsn", "for", "the", "common", "case", "of", "no", "carrier", "code", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1769-L1772
19
ttacon/libphonenumber
phonenumberutil.go
formatNsnUsingPattern
func formatNsnUsingPattern( nationalNumber string, formattingPattern *NumberFormat, numberFormat PhoneNumberFormat) string { return formatNsnUsingPatternWithCarrier( nationalNumber, formattingPattern, numberFormat, "") }
go
func formatNsnUsingPattern( nationalNumber string, formattingPattern *NumberFormat, numberFormat PhoneNumberFormat) string { return formatNsnUsingPatternWithCarrier( nationalNumber, formattingPattern, numberFormat, "") }
[ "func", "formatNsnUsingPattern", "(", "nationalNumber", "string", ",", "formattingPattern", "*", "NumberFormat", ",", "numberFormat", "PhoneNumberFormat", ")", "string", "{", "return", "formatNsnUsingPatternWithCarrier", "(", "nationalNumber", ",", "formattingPattern", ",", "numberFormat", ",", "\"", "\"", ")", "\n", "}" ]
// Simple wrapper of formatNsnUsingPattern for the common case of no carrier code.
[ "Simple", "wrapper", "of", "formatNsnUsingPattern", "for", "the", "common", "case", "of", "no", "carrier", "code", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1844-L1850
20
ttacon/libphonenumber
phonenumberutil.go
formatNsnUsingPatternWithCarrier
func formatNsnUsingPatternWithCarrier( nationalNumber string, formattingPattern *NumberFormat, numberFormat PhoneNumberFormat, carrierCode string) string { numberFormatRule := formattingPattern.GetFormat() m, ok := readFromRegexCache(formattingPattern.GetPattern()) if !ok { pat := formattingPattern.GetPattern() m = regexp.MustCompile(pat) writeToRegexCache(pat, m) } formattedNationalNumber := "" if numberFormat == NATIONAL && len(carrierCode) > 0 && len(formattingPattern.GetDomesticCarrierCodeFormattingRule()) > 0 { // Replace the $CC in the formatting rule with the desired carrier code. carrierCodeFormattingRule := formattingPattern.GetDomesticCarrierCodeFormattingRule() i := 1 carrierCodeFormattingRule = CC_PATTERN.ReplaceAllStringFunc(carrierCodeFormattingRule, func(s string) string { if i > 0 { i -= 1 return carrierCode } return s }) // Now replace the $FG in the formatting rule with the first group // and the carrier code combined in the appropriate way. i = 1 numberFormatRule = FIRST_GROUP_PATTERN.ReplaceAllStringFunc( numberFormatRule, func(s string) string { if i > 0 { i -= 1 return carrierCodeFormattingRule } return s }) formattedNationalNumber = m.ReplaceAllString(numberFormatRule, nationalNumber) } else { // Use the national prefix formatting rule instead. nationalPrefixFormattingRule := formattingPattern.GetNationalPrefixFormattingRule() if numberFormat == NATIONAL && len(nationalPrefixFormattingRule) > 0 { i := 1 fgp := FIRST_GROUP_PATTERN.ReplaceAllStringFunc(numberFormatRule, func(s string) string { if i > 0 { i -= 1 return nationalPrefixFormattingRule } return s }) formattedNationalNumber = m.ReplaceAllString(nationalNumber, fgp) } else { formattedNationalNumber = m.ReplaceAllString( nationalNumber, numberFormatRule, ) } } if numberFormat == RFC3966 { // Strip any leading punctuation. inds := SEPARATOR_PATTERN.FindStringIndex(formattedNationalNumber) if len(inds) > 0 && inds[0] == 0 { formattedNationalNumber = formattedNationalNumber[inds[1]:] } allStr := NOT_SEPARATOR_PATTERN.FindAllString(formattedNationalNumber, -1) formattedNationalNumber = strings.Join(allStr, "-") } return formattedNationalNumber }
go
func formatNsnUsingPatternWithCarrier( nationalNumber string, formattingPattern *NumberFormat, numberFormat PhoneNumberFormat, carrierCode string) string { numberFormatRule := formattingPattern.GetFormat() m, ok := readFromRegexCache(formattingPattern.GetPattern()) if !ok { pat := formattingPattern.GetPattern() m = regexp.MustCompile(pat) writeToRegexCache(pat, m) } formattedNationalNumber := "" if numberFormat == NATIONAL && len(carrierCode) > 0 && len(formattingPattern.GetDomesticCarrierCodeFormattingRule()) > 0 { // Replace the $CC in the formatting rule with the desired carrier code. carrierCodeFormattingRule := formattingPattern.GetDomesticCarrierCodeFormattingRule() i := 1 carrierCodeFormattingRule = CC_PATTERN.ReplaceAllStringFunc(carrierCodeFormattingRule, func(s string) string { if i > 0 { i -= 1 return carrierCode } return s }) // Now replace the $FG in the formatting rule with the first group // and the carrier code combined in the appropriate way. i = 1 numberFormatRule = FIRST_GROUP_PATTERN.ReplaceAllStringFunc( numberFormatRule, func(s string) string { if i > 0 { i -= 1 return carrierCodeFormattingRule } return s }) formattedNationalNumber = m.ReplaceAllString(numberFormatRule, nationalNumber) } else { // Use the national prefix formatting rule instead. nationalPrefixFormattingRule := formattingPattern.GetNationalPrefixFormattingRule() if numberFormat == NATIONAL && len(nationalPrefixFormattingRule) > 0 { i := 1 fgp := FIRST_GROUP_PATTERN.ReplaceAllStringFunc(numberFormatRule, func(s string) string { if i > 0 { i -= 1 return nationalPrefixFormattingRule } return s }) formattedNationalNumber = m.ReplaceAllString(nationalNumber, fgp) } else { formattedNationalNumber = m.ReplaceAllString( nationalNumber, numberFormatRule, ) } } if numberFormat == RFC3966 { // Strip any leading punctuation. inds := SEPARATOR_PATTERN.FindStringIndex(formattedNationalNumber) if len(inds) > 0 && inds[0] == 0 { formattedNationalNumber = formattedNationalNumber[inds[1]:] } allStr := NOT_SEPARATOR_PATTERN.FindAllString(formattedNationalNumber, -1) formattedNationalNumber = strings.Join(allStr, "-") } return formattedNationalNumber }
[ "func", "formatNsnUsingPatternWithCarrier", "(", "nationalNumber", "string", ",", "formattingPattern", "*", "NumberFormat", ",", "numberFormat", "PhoneNumberFormat", ",", "carrierCode", "string", ")", "string", "{", "numberFormatRule", ":=", "formattingPattern", ".", "GetFormat", "(", ")", "\n", "m", ",", "ok", ":=", "readFromRegexCache", "(", "formattingPattern", ".", "GetPattern", "(", ")", ")", "\n", "if", "!", "ok", "{", "pat", ":=", "formattingPattern", ".", "GetPattern", "(", ")", "\n", "m", "=", "regexp", ".", "MustCompile", "(", "pat", ")", "\n", "writeToRegexCache", "(", "pat", ",", "m", ")", "\n", "}", "\n\n", "formattedNationalNumber", ":=", "\"", "\"", "\n", "if", "numberFormat", "==", "NATIONAL", "&&", "len", "(", "carrierCode", ")", ">", "0", "&&", "len", "(", "formattingPattern", ".", "GetDomesticCarrierCodeFormattingRule", "(", ")", ")", ">", "0", "{", "// Replace the $CC in the formatting rule with the desired carrier code.", "carrierCodeFormattingRule", ":=", "formattingPattern", ".", "GetDomesticCarrierCodeFormattingRule", "(", ")", "\n", "i", ":=", "1", "\n", "carrierCodeFormattingRule", "=", "CC_PATTERN", ".", "ReplaceAllStringFunc", "(", "carrierCodeFormattingRule", ",", "func", "(", "s", "string", ")", "string", "{", "if", "i", ">", "0", "{", "i", "-=", "1", "\n", "return", "carrierCode", "\n", "}", "\n", "return", "s", "\n", "}", ")", "\n", "// Now replace the $FG in the formatting rule with the first group", "// and the carrier code combined in the appropriate way.", "i", "=", "1", "\n", "numberFormatRule", "=", "FIRST_GROUP_PATTERN", ".", "ReplaceAllStringFunc", "(", "numberFormatRule", ",", "func", "(", "s", "string", ")", "string", "{", "if", "i", ">", "0", "{", "i", "-=", "1", "\n", "return", "carrierCodeFormattingRule", "\n", "}", "\n", "return", "s", "\n", "}", ")", "\n", "formattedNationalNumber", "=", "m", ".", "ReplaceAllString", "(", "numberFormatRule", ",", "nationalNumber", ")", "\n", "}", "else", "{", "// Use the national prefix formatting rule instead.", "nationalPrefixFormattingRule", ":=", "formattingPattern", ".", "GetNationalPrefixFormattingRule", "(", ")", "\n", "if", "numberFormat", "==", "NATIONAL", "&&", "len", "(", "nationalPrefixFormattingRule", ")", ">", "0", "{", "i", ":=", "1", "\n", "fgp", ":=", "FIRST_GROUP_PATTERN", ".", "ReplaceAllStringFunc", "(", "numberFormatRule", ",", "func", "(", "s", "string", ")", "string", "{", "if", "i", ">", "0", "{", "i", "-=", "1", "\n", "return", "nationalPrefixFormattingRule", "\n", "}", "\n", "return", "s", "\n", "}", ")", "\n", "formattedNationalNumber", "=", "m", ".", "ReplaceAllString", "(", "nationalNumber", ",", "fgp", ")", "\n", "}", "else", "{", "formattedNationalNumber", "=", "m", ".", "ReplaceAllString", "(", "nationalNumber", ",", "numberFormatRule", ",", ")", "\n", "}", "\n", "}", "\n", "if", "numberFormat", "==", "RFC3966", "{", "// Strip any leading punctuation.", "inds", ":=", "SEPARATOR_PATTERN", ".", "FindStringIndex", "(", "formattedNationalNumber", ")", "\n", "if", "len", "(", "inds", ")", ">", "0", "&&", "inds", "[", "0", "]", "==", "0", "{", "formattedNationalNumber", "=", "formattedNationalNumber", "[", "inds", "[", "1", "]", ":", "]", "\n", "}", "\n", "allStr", ":=", "NOT_SEPARATOR_PATTERN", ".", "FindAllString", "(", "formattedNationalNumber", ",", "-", "1", ")", "\n", "formattedNationalNumber", "=", "strings", ".", "Join", "(", "allStr", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "formattedNationalNumber", "\n", "}" ]
// Note that carrierCode is optional - if null or an empty string, no // carrier code replacement will take place.
[ "Note", "that", "carrierCode", "is", "optional", "-", "if", "null", "or", "an", "empty", "string", "no", "carrier", "code", "replacement", "will", "take", "place", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1854-L1930
21
ttacon/libphonenumber
phonenumberutil.go
GetExampleNumberForType
func GetExampleNumberForType(regionCode string, typ PhoneNumberType) *PhoneNumber { // Check the region code is valid. if !isValidRegionCode(regionCode) { return nil } //PhoneNumberDesc (pointer?) var desc = getNumberDescByType(getMetadataForRegion(regionCode), typ) exNum := desc.GetExampleNumber() if len(exNum) > 0 { num, err := Parse(exNum, regionCode) if err != nil { return nil } return num } return nil }
go
func GetExampleNumberForType(regionCode string, typ PhoneNumberType) *PhoneNumber { // Check the region code is valid. if !isValidRegionCode(regionCode) { return nil } //PhoneNumberDesc (pointer?) var desc = getNumberDescByType(getMetadataForRegion(regionCode), typ) exNum := desc.GetExampleNumber() if len(exNum) > 0 { num, err := Parse(exNum, regionCode) if err != nil { return nil } return num } return nil }
[ "func", "GetExampleNumberForType", "(", "regionCode", "string", ",", "typ", "PhoneNumberType", ")", "*", "PhoneNumber", "{", "// Check the region code is valid.", "if", "!", "isValidRegionCode", "(", "regionCode", ")", "{", "return", "nil", "\n", "}", "\n", "//PhoneNumberDesc (pointer?)", "var", "desc", "=", "getNumberDescByType", "(", "getMetadataForRegion", "(", "regionCode", ")", ",", "typ", ")", "\n", "exNum", ":=", "desc", ".", "GetExampleNumber", "(", ")", "\n", "if", "len", "(", "exNum", ")", ">", "0", "{", "num", ",", "err", ":=", "Parse", "(", "exNum", ",", "regionCode", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "num", "\n", "}", "\n", "return", "nil", "\n", "}" ]
// Gets a valid number for the specified region and number type.
[ "Gets", "a", "valid", "number", "for", "the", "specified", "region", "and", "number", "type", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1938-L1954
22
ttacon/libphonenumber
phonenumberutil.go
GetExampleNumberForNonGeoEntity
func GetExampleNumberForNonGeoEntity(countryCallingCode int) *PhoneNumber { var metadata *PhoneMetadata = getMetadataForNonGeographicalRegion(countryCallingCode) if metadata == nil { return nil } var desc *PhoneNumberDesc = metadata.GetTollFree() if countryCallingCode == 979 { desc = metadata.GetPremiumRate() } exNum := desc.GetExampleNumber() if len(exNum) > 0 { num, err := Parse("+"+strconv.Itoa(countryCallingCode)+exNum, "ZZ") if err != nil { return nil } return num } return nil }
go
func GetExampleNumberForNonGeoEntity(countryCallingCode int) *PhoneNumber { var metadata *PhoneMetadata = getMetadataForNonGeographicalRegion(countryCallingCode) if metadata == nil { return nil } var desc *PhoneNumberDesc = metadata.GetTollFree() if countryCallingCode == 979 { desc = metadata.GetPremiumRate() } exNum := desc.GetExampleNumber() if len(exNum) > 0 { num, err := Parse("+"+strconv.Itoa(countryCallingCode)+exNum, "ZZ") if err != nil { return nil } return num } return nil }
[ "func", "GetExampleNumberForNonGeoEntity", "(", "countryCallingCode", "int", ")", "*", "PhoneNumber", "{", "var", "metadata", "*", "PhoneMetadata", "=", "getMetadataForNonGeographicalRegion", "(", "countryCallingCode", ")", "\n", "if", "metadata", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "var", "desc", "*", "PhoneNumberDesc", "=", "metadata", ".", "GetTollFree", "(", ")", "\n\n", "if", "countryCallingCode", "==", "979", "{", "desc", "=", "metadata", ".", "GetPremiumRate", "(", ")", "\n", "}", "\n\n", "exNum", ":=", "desc", ".", "GetExampleNumber", "(", ")", "\n", "if", "len", "(", "exNum", ")", ">", "0", "{", "num", ",", "err", ":=", "Parse", "(", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "countryCallingCode", ")", "+", "exNum", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "num", "\n", "}", "\n", "return", "nil", "\n", "}" ]
// Gets a valid number for the specified country calling code for a // non-geographical entity.
[ "Gets", "a", "valid", "number", "for", "the", "specified", "country", "calling", "code", "for", "a", "non", "-", "geographical", "entity", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1958-L1978
23
ttacon/libphonenumber
phonenumberutil.go
maybeAppendFormattedExtension
func maybeAppendFormattedExtension( number *PhoneNumber, metadata *PhoneMetadata, numberFormat PhoneNumberFormat, formattedNumber *builder.Builder) { extension := number.GetExtension() if len(extension) == 0 { return } prefExtn := metadata.GetPreferredExtnPrefix() if numberFormat == RFC3966 { formattedNumber.WriteString(RFC3966_EXTN_PREFIX) } else if len(prefExtn) > 0 { formattedNumber.WriteString(prefExtn) } else { formattedNumber.WriteString(DEFAULT_EXTN_PREFIX) } formattedNumber.WriteString(extension) }
go
func maybeAppendFormattedExtension( number *PhoneNumber, metadata *PhoneMetadata, numberFormat PhoneNumberFormat, formattedNumber *builder.Builder) { extension := number.GetExtension() if len(extension) == 0 { return } prefExtn := metadata.GetPreferredExtnPrefix() if numberFormat == RFC3966 { formattedNumber.WriteString(RFC3966_EXTN_PREFIX) } else if len(prefExtn) > 0 { formattedNumber.WriteString(prefExtn) } else { formattedNumber.WriteString(DEFAULT_EXTN_PREFIX) } formattedNumber.WriteString(extension) }
[ "func", "maybeAppendFormattedExtension", "(", "number", "*", "PhoneNumber", ",", "metadata", "*", "PhoneMetadata", ",", "numberFormat", "PhoneNumberFormat", ",", "formattedNumber", "*", "builder", ".", "Builder", ")", "{", "extension", ":=", "number", ".", "GetExtension", "(", ")", "\n", "if", "len", "(", "extension", ")", "==", "0", "{", "return", "\n", "}", "\n\n", "prefExtn", ":=", "metadata", ".", "GetPreferredExtnPrefix", "(", ")", "\n", "if", "numberFormat", "==", "RFC3966", "{", "formattedNumber", ".", "WriteString", "(", "RFC3966_EXTN_PREFIX", ")", "\n", "}", "else", "if", "len", "(", "prefExtn", ")", ">", "0", "{", "formattedNumber", ".", "WriteString", "(", "prefExtn", ")", "\n", "}", "else", "{", "formattedNumber", ".", "WriteString", "(", "DEFAULT_EXTN_PREFIX", ")", "\n", "}", "\n", "formattedNumber", ".", "WriteString", "(", "extension", ")", "\n", "}" ]
// Appends the formatted extension of a phone number to formattedNumber, // if the phone number had an extension specified.
[ "Appends", "the", "formatted", "extension", "of", "a", "phone", "number", "to", "formattedNumber", "if", "the", "phone", "number", "had", "an", "extension", "specified", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1982-L2002
24
ttacon/libphonenumber
phonenumberutil.go
GetNumberType
func GetNumberType(number *PhoneNumber) PhoneNumberType { var regionCode string = GetRegionCodeForNumber(number) var metadata *PhoneMetadata = getMetadataForRegionOrCallingCode( int(number.GetCountryCode()), regionCode) if metadata == nil { return UNKNOWN } var nationalSignificantNumber = GetNationalSignificantNumber(number) return getNumberTypeHelper(nationalSignificantNumber, metadata) }
go
func GetNumberType(number *PhoneNumber) PhoneNumberType { var regionCode string = GetRegionCodeForNumber(number) var metadata *PhoneMetadata = getMetadataForRegionOrCallingCode( int(number.GetCountryCode()), regionCode) if metadata == nil { return UNKNOWN } var nationalSignificantNumber = GetNationalSignificantNumber(number) return getNumberTypeHelper(nationalSignificantNumber, metadata) }
[ "func", "GetNumberType", "(", "number", "*", "PhoneNumber", ")", "PhoneNumberType", "{", "var", "regionCode", "string", "=", "GetRegionCodeForNumber", "(", "number", ")", "\n", "var", "metadata", "*", "PhoneMetadata", "=", "getMetadataForRegionOrCallingCode", "(", "int", "(", "number", ".", "GetCountryCode", "(", ")", ")", ",", "regionCode", ")", "\n", "if", "metadata", "==", "nil", "{", "return", "UNKNOWN", "\n", "}", "\n", "var", "nationalSignificantNumber", "=", "GetNationalSignificantNumber", "(", "number", ")", "\n", "return", "getNumberTypeHelper", "(", "nationalSignificantNumber", ",", "metadata", ")", "\n", "}" ]
// Gets the type of a phone number.
[ "Gets", "the", "type", "of", "a", "phone", "number", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2037-L2046
25
ttacon/libphonenumber
phonenumberutil.go
getMetadataForRegion
func getMetadataForRegion(regionCode string) *PhoneMetadata { if !isValidRegionCode(regionCode) { return nil } val, _ := readFromRegionToMetadataMap(regionCode) return val }
go
func getMetadataForRegion(regionCode string) *PhoneMetadata { if !isValidRegionCode(regionCode) { return nil } val, _ := readFromRegionToMetadataMap(regionCode) return val }
[ "func", "getMetadataForRegion", "(", "regionCode", "string", ")", "*", "PhoneMetadata", "{", "if", "!", "isValidRegionCode", "(", "regionCode", ")", "{", "return", "nil", "\n", "}", "\n", "val", ",", "_", ":=", "readFromRegionToMetadataMap", "(", "regionCode", ")", "\n", "return", "val", "\n", "}" ]
// Returns the metadata for the given region code or nil if the region // code is invalid or unknown.
[ "Returns", "the", "metadata", "for", "the", "given", "region", "code", "or", "nil", "if", "the", "region", "code", "is", "invalid", "or", "unknown", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2106-L2112
26
ttacon/libphonenumber
phonenumberutil.go
IsValidNumber
func IsValidNumber(number *PhoneNumber) bool { var regionCode string = GetRegionCodeForNumber(number) return IsValidNumberForRegion(number, regionCode) }
go
func IsValidNumber(number *PhoneNumber) bool { var regionCode string = GetRegionCodeForNumber(number) return IsValidNumberForRegion(number, regionCode) }
[ "func", "IsValidNumber", "(", "number", "*", "PhoneNumber", ")", "bool", "{", "var", "regionCode", "string", "=", "GetRegionCodeForNumber", "(", "number", ")", "\n", "return", "IsValidNumberForRegion", "(", "number", ",", "regionCode", ")", "\n", "}" ]
// Tests whether a phone number matches a valid pattern. Note this doesn't // verify the number is actually in use, which is impossible to tell by // just looking at a number itself.
[ "Tests", "whether", "a", "phone", "number", "matches", "a", "valid", "pattern", ".", "Note", "this", "doesn", "t", "verify", "the", "number", "is", "actually", "in", "use", "which", "is", "impossible", "to", "tell", "by", "just", "looking", "at", "a", "number", "itself", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2154-L2157
27
ttacon/libphonenumber
phonenumberutil.go
GetRegionCodeForNumber
func GetRegionCodeForNumber(number *PhoneNumber) string { var countryCode int = int(number.GetCountryCode()) var regions []string = CountryCodeToRegion[countryCode] if len(regions) == 0 { return "" } if len(regions) == 1 { return regions[0] } return getRegionCodeForNumberFromRegionList(number, regions) }
go
func GetRegionCodeForNumber(number *PhoneNumber) string { var countryCode int = int(number.GetCountryCode()) var regions []string = CountryCodeToRegion[countryCode] if len(regions) == 0 { return "" } if len(regions) == 1 { return regions[0] } return getRegionCodeForNumberFromRegionList(number, regions) }
[ "func", "GetRegionCodeForNumber", "(", "number", "*", "PhoneNumber", ")", "string", "{", "var", "countryCode", "int", "=", "int", "(", "number", ".", "GetCountryCode", "(", ")", ")", "\n", "var", "regions", "[", "]", "string", "=", "CountryCodeToRegion", "[", "countryCode", "]", "\n", "if", "len", "(", "regions", ")", "==", "0", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "len", "(", "regions", ")", "==", "1", "{", "return", "regions", "[", "0", "]", "\n", "}", "\n", "return", "getRegionCodeForNumberFromRegionList", "(", "number", ",", "regions", ")", "\n", "}" ]
// Returns the region where a phone number is from. This could be used for // geocoding at the region level.
[ "Returns", "the", "region", "where", "a", "phone", "number", "is", "from", ".", "This", "could", "be", "used", "for", "geocoding", "at", "the", "region", "level", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2198-L2208
28
ttacon/libphonenumber
phonenumberutil.go
getCountryCodeForValidRegion
func getCountryCodeForValidRegion(regionCode string) int { var metadata *PhoneMetadata = getMetadataForRegion(regionCode) return int(metadata.GetCountryCode()) }
go
func getCountryCodeForValidRegion(regionCode string) int { var metadata *PhoneMetadata = getMetadataForRegion(regionCode) return int(metadata.GetCountryCode()) }
[ "func", "getCountryCodeForValidRegion", "(", "regionCode", "string", ")", "int", "{", "var", "metadata", "*", "PhoneMetadata", "=", "getMetadataForRegion", "(", "regionCode", ")", "\n", "return", "int", "(", "metadata", ".", "GetCountryCode", "(", ")", ")", "\n", "}" ]
// Returns the country calling code for a specific region. For example, // this would be 1 for the United States, and 64 for New Zealand. Assumes // the region is already valid.
[ "Returns", "the", "country", "calling", "code", "for", "a", "specific", "region", ".", "For", "example", "this", "would", "be", "1", "for", "the", "United", "States", "and", "64", "for", "New", "Zealand", ".", "Assumes", "the", "region", "is", "already", "valid", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2274-L2277
29
ttacon/libphonenumber
phonenumberutil.go
isLeadingZeroPossible
func isLeadingZeroPossible(countryCallingCode int) bool { var mainMetadataForCallingCode *PhoneMetadata = getMetadataForRegionOrCallingCode( countryCallingCode, GetRegionCodeForCountryCode(countryCallingCode), ) return mainMetadataForCallingCode.GetLeadingZeroPossible() }
go
func isLeadingZeroPossible(countryCallingCode int) bool { var mainMetadataForCallingCode *PhoneMetadata = getMetadataForRegionOrCallingCode( countryCallingCode, GetRegionCodeForCountryCode(countryCallingCode), ) return mainMetadataForCallingCode.GetLeadingZeroPossible() }
[ "func", "isLeadingZeroPossible", "(", "countryCallingCode", "int", ")", "bool", "{", "var", "mainMetadataForCallingCode", "*", "PhoneMetadata", "=", "getMetadataForRegionOrCallingCode", "(", "countryCallingCode", ",", "GetRegionCodeForCountryCode", "(", "countryCallingCode", ")", ",", ")", "\n", "return", "mainMetadataForCallingCode", ".", "GetLeadingZeroPossible", "(", ")", "\n", "}" ]
// Checks whether the country calling code is from a region whose national // significant number could contain a leading zero. An example of such a // region is Italy. Returns false if no metadata for the country is found.
[ "Checks", "whether", "the", "country", "calling", "code", "is", "from", "a", "region", "whose", "national", "significant", "number", "could", "contain", "a", "leading", "zero", ".", "An", "example", "of", "such", "a", "region", "is", "Italy", ".", "Returns", "false", "if", "no", "metadata", "for", "the", "country", "is", "found", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2317-L2323
30
ttacon/libphonenumber
phonenumberutil.go
isShorterThanPossibleNormalNumber
func isShorterThanPossibleNormalNumber( regionMetadata *PhoneMetadata, number string) bool { pat, ok := readFromRegexCache(regionMetadata.GetGeneralDesc().GetNationalNumberPattern()) if !ok { patP := regionMetadata.GetGeneralDesc().GetNationalNumberPattern() pat = regexp.MustCompile(patP) writeToRegexCache(patP, pat) } return testNumberLengthAgainstPattern(pat, number) == TOO_SHORT }
go
func isShorterThanPossibleNormalNumber( regionMetadata *PhoneMetadata, number string) bool { pat, ok := readFromRegexCache(regionMetadata.GetGeneralDesc().GetNationalNumberPattern()) if !ok { patP := regionMetadata.GetGeneralDesc().GetNationalNumberPattern() pat = regexp.MustCompile(patP) writeToRegexCache(patP, pat) } return testNumberLengthAgainstPattern(pat, number) == TOO_SHORT }
[ "func", "isShorterThanPossibleNormalNumber", "(", "regionMetadata", "*", "PhoneMetadata", ",", "number", "string", ")", "bool", "{", "pat", ",", "ok", ":=", "readFromRegexCache", "(", "regionMetadata", ".", "GetGeneralDesc", "(", ")", ".", "GetNationalNumberPattern", "(", ")", ")", "\n", "if", "!", "ok", "{", "patP", ":=", "regionMetadata", ".", "GetGeneralDesc", "(", ")", ".", "GetNationalNumberPattern", "(", ")", "\n", "pat", "=", "regexp", ".", "MustCompile", "(", "patP", ")", "\n", "writeToRegexCache", "(", "patP", ",", "pat", ")", "\n", "}", "\n", "return", "testNumberLengthAgainstPattern", "(", "pat", ",", "number", ")", "==", "TOO_SHORT", "\n", "}" ]
// Helper method to check whether a number is too short to be a regular // length phone number in a region.
[ "Helper", "method", "to", "check", "whether", "a", "number", "is", "too", "short", "to", "be", "a", "regular", "length", "phone", "number", "in", "a", "region", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2370-L2381
31
ttacon/libphonenumber
phonenumberutil.go
TruncateTooLongNumber
func TruncateTooLongNumber(number *PhoneNumber) bool { if IsValidNumber(number) { return true } var numberCopy *PhoneNumber proto.Merge(numberCopy, number) nationalNumber := number.GetNationalNumber() nationalNumber /= 10 numberCopy.NationalNumber = proto.Uint64(nationalNumber) if IsPossibleNumberWithReason(numberCopy) == TOO_SHORT || nationalNumber == 0 { return false } for !IsValidNumber(numberCopy) { nationalNumber /= 10 numberCopy.NationalNumber = proto.Uint64(nationalNumber) if IsPossibleNumberWithReason(numberCopy) == TOO_SHORT || nationalNumber == 0 { return false } } number.NationalNumber = proto.Uint64(nationalNumber) return true }
go
func TruncateTooLongNumber(number *PhoneNumber) bool { if IsValidNumber(number) { return true } var numberCopy *PhoneNumber proto.Merge(numberCopy, number) nationalNumber := number.GetNationalNumber() nationalNumber /= 10 numberCopy.NationalNumber = proto.Uint64(nationalNumber) if IsPossibleNumberWithReason(numberCopy) == TOO_SHORT || nationalNumber == 0 { return false } for !IsValidNumber(numberCopy) { nationalNumber /= 10 numberCopy.NationalNumber = proto.Uint64(nationalNumber) if IsPossibleNumberWithReason(numberCopy) == TOO_SHORT || nationalNumber == 0 { return false } } number.NationalNumber = proto.Uint64(nationalNumber) return true }
[ "func", "TruncateTooLongNumber", "(", "number", "*", "PhoneNumber", ")", "bool", "{", "if", "IsValidNumber", "(", "number", ")", "{", "return", "true", "\n", "}", "\n", "var", "numberCopy", "*", "PhoneNumber", "\n", "proto", ".", "Merge", "(", "numberCopy", ",", "number", ")", "\n", "nationalNumber", ":=", "number", ".", "GetNationalNumber", "(", ")", "\n", "nationalNumber", "/=", "10", "\n", "numberCopy", ".", "NationalNumber", "=", "proto", ".", "Uint64", "(", "nationalNumber", ")", "\n", "if", "IsPossibleNumberWithReason", "(", "numberCopy", ")", "==", "TOO_SHORT", "||", "nationalNumber", "==", "0", "{", "return", "false", "\n", "}", "\n", "for", "!", "IsValidNumber", "(", "numberCopy", ")", "{", "nationalNumber", "/=", "10", "\n", "numberCopy", ".", "NationalNumber", "=", "proto", ".", "Uint64", "(", "nationalNumber", ")", "\n", "if", "IsPossibleNumberWithReason", "(", "numberCopy", ")", "==", "TOO_SHORT", "||", "nationalNumber", "==", "0", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "number", ".", "NationalNumber", "=", "proto", ".", "Uint64", "(", "nationalNumber", ")", "\n", "return", "true", "\n", "}" ]
// Attempts to extract a valid number from a phone number that is too long // to be valid, and resets the PhoneNumber object passed in to that valid // version. If no valid number could be extracted, the PhoneNumber object // passed in will not be modified.
[ "Attempts", "to", "extract", "a", "valid", "number", "from", "a", "phone", "number", "that", "is", "too", "long", "to", "be", "valid", "and", "resets", "the", "PhoneNumber", "object", "passed", "in", "to", "that", "valid", "version", ".", "If", "no", "valid", "number", "could", "be", "extracted", "the", "PhoneNumber", "object", "passed", "in", "will", "not", "be", "modified", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2457-L2480
32
ttacon/libphonenumber
phonenumberutil.go
parsePrefixAsIdd
func parsePrefixAsIdd(iddPattern *regexp.Regexp, number *builder.Builder) bool { numStr := number.String() ind := iddPattern.FindStringIndex(numStr) if len(ind) == 0 || ind[0] != 0 { return false } matchEnd := ind[1] // ind is a two element slice // Only strip this if the first digit after the match is not // a 0, since country calling codes cannot begin with 0. find := CAPTURING_DIGIT_PATTERN.FindAllString(numStr[matchEnd:], -1) if len(find) > 0 { if NormalizeDigitsOnly(find[0]) == "0" { return false } } numBytes := []byte(numStr) number.ResetWith(numBytes[matchEnd:]) return true }
go
func parsePrefixAsIdd(iddPattern *regexp.Regexp, number *builder.Builder) bool { numStr := number.String() ind := iddPattern.FindStringIndex(numStr) if len(ind) == 0 || ind[0] != 0 { return false } matchEnd := ind[1] // ind is a two element slice // Only strip this if the first digit after the match is not // a 0, since country calling codes cannot begin with 0. find := CAPTURING_DIGIT_PATTERN.FindAllString(numStr[matchEnd:], -1) if len(find) > 0 { if NormalizeDigitsOnly(find[0]) == "0" { return false } } numBytes := []byte(numStr) number.ResetWith(numBytes[matchEnd:]) return true }
[ "func", "parsePrefixAsIdd", "(", "iddPattern", "*", "regexp", ".", "Regexp", ",", "number", "*", "builder", ".", "Builder", ")", "bool", "{", "numStr", ":=", "number", ".", "String", "(", ")", "\n", "ind", ":=", "iddPattern", ".", "FindStringIndex", "(", "numStr", ")", "\n", "if", "len", "(", "ind", ")", "==", "0", "||", "ind", "[", "0", "]", "!=", "0", "{", "return", "false", "\n", "}", "\n", "matchEnd", ":=", "ind", "[", "1", "]", "// ind is a two element slice", "\n", "// Only strip this if the first digit after the match is not", "// a 0, since country calling codes cannot begin with 0.", "find", ":=", "CAPTURING_DIGIT_PATTERN", ".", "FindAllString", "(", "numStr", "[", "matchEnd", ":", "]", ",", "-", "1", ")", "\n", "if", "len", "(", "find", ")", ">", "0", "{", "if", "NormalizeDigitsOnly", "(", "find", "[", "0", "]", ")", "==", "\"", "\"", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "numBytes", ":=", "[", "]", "byte", "(", "numStr", ")", "\n", "number", ".", "ResetWith", "(", "numBytes", "[", "matchEnd", ":", "]", ")", "\n", "return", "true", "\n", "}" ]
// Strips the IDD from the start of the number if present. Helper function // used by maybeStripInternationalPrefixAndNormalize.
[ "Strips", "the", "IDD", "from", "the", "start", "of", "the", "number", "if", "present", ".", "Helper", "function", "used", "by", "maybeStripInternationalPrefixAndNormalize", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2625-L2644
33
ttacon/libphonenumber
phonenumberutil.go
checkRegionForParsing
func checkRegionForParsing(numberToParse, defaultRegion string) bool { if !isValidRegionCode(defaultRegion) { // If the number is null or empty, we can't infer the region. if len(numberToParse) == 0 || !PLUS_CHARS_PATTERN.MatchString(numberToParse) { return false } } return true }
go
func checkRegionForParsing(numberToParse, defaultRegion string) bool { if !isValidRegionCode(defaultRegion) { // If the number is null or empty, we can't infer the region. if len(numberToParse) == 0 || !PLUS_CHARS_PATTERN.MatchString(numberToParse) { return false } } return true }
[ "func", "checkRegionForParsing", "(", "numberToParse", ",", "defaultRegion", "string", ")", "bool", "{", "if", "!", "isValidRegionCode", "(", "defaultRegion", ")", "{", "// If the number is null or empty, we can't infer the region.", "if", "len", "(", "numberToParse", ")", "==", "0", "||", "!", "PLUS_CHARS_PATTERN", ".", "MatchString", "(", "numberToParse", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]
// Checks to see that the region code used is valid, or if it is not valid, // that the number to parse starts with a + symbol so that we can attempt // to infer the region from the number. Returns false if it cannot use the // region provided and the region cannot be inferred.
[ "Checks", "to", "see", "that", "the", "region", "code", "used", "is", "valid", "or", "if", "it", "is", "not", "valid", "that", "the", "number", "to", "parse", "starts", "with", "a", "+", "symbol", "so", "that", "we", "can", "attempt", "to", "infer", "the", "region", "from", "the", "number", ".", "Returns", "false", "if", "it", "cannot", "use", "the", "region", "provided", "and", "the", "region", "cannot", "be", "inferred", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2786-L2795
34
ttacon/libphonenumber
phonenumberutil.go
buildNationalNumberForParsing
func buildNationalNumberForParsing( numberToParse string, nationalNumber *builder.Builder) { indexOfPhoneContext := strings.Index(numberToParse, RFC3966_PHONE_CONTEXT) if indexOfPhoneContext > 0 { phoneContextStart := indexOfPhoneContext + len(RFC3966_PHONE_CONTEXT) // If the phone context contains a phone number prefix, we need // to capture it, whereas domains will be ignored. if numberToParse[phoneContextStart] == PLUS_SIGN { // Additional parameters might follow the phone context. If so, // we will remove them here because the parameters after phone // context are not important for parsing the phone number. phoneContextEnd := strings.Index(numberToParse[phoneContextStart:], ";") if phoneContextEnd > 0 { nationalNumber.WriteString( numberToParse[phoneContextStart:phoneContextEnd]) } else { nationalNumber.WriteString(numberToParse[phoneContextStart:]) } } // Now append everything between the "tel:" prefix and the // phone-context. This should include the national number, an // optional extension or isdn-subaddress component. Note we also // handle the case when "tel:" is missing, as we have seen in some // of the phone number inputs. In that case, we append everything // from the beginning. indexOfRfc3966Prefix := strings.Index(numberToParse, RFC3966_PREFIX) indexOfNationalNumber := 0 if indexOfRfc3966Prefix >= 0 { indexOfNationalNumber = indexOfRfc3966Prefix + len(RFC3966_PREFIX) } nationalNumber.WriteString( numberToParse[indexOfNationalNumber:indexOfPhoneContext]) } else { // Extract a possible number from the string passed in (this // strips leading characters that could not be the start of a // phone number.) nationalNumber.WriteString(extractPossibleNumber(numberToParse)) } // Delete the isdn-subaddress and everything after it if it is present. // Note extension won't appear at the same time with isdn-subaddress // according to paragraph 5.3 of the RFC3966 spec, indexOfIsdn := strings.Index(nationalNumber.String(), RFC3966_ISDN_SUBADDRESS) if indexOfIsdn > 0 { natNumBytes := nationalNumber.Bytes() nationalNumber.ResetWith(natNumBytes[:indexOfIsdn]) } // If both phone context and isdn-subaddress are absent but other // parameters are present, the parameters are left in nationalNumber. // This is because we are concerned about deleting content from a // potential number string when there is no strong evidence that the // number is actually written in RFC3966. }
go
func buildNationalNumberForParsing( numberToParse string, nationalNumber *builder.Builder) { indexOfPhoneContext := strings.Index(numberToParse, RFC3966_PHONE_CONTEXT) if indexOfPhoneContext > 0 { phoneContextStart := indexOfPhoneContext + len(RFC3966_PHONE_CONTEXT) // If the phone context contains a phone number prefix, we need // to capture it, whereas domains will be ignored. if numberToParse[phoneContextStart] == PLUS_SIGN { // Additional parameters might follow the phone context. If so, // we will remove them here because the parameters after phone // context are not important for parsing the phone number. phoneContextEnd := strings.Index(numberToParse[phoneContextStart:], ";") if phoneContextEnd > 0 { nationalNumber.WriteString( numberToParse[phoneContextStart:phoneContextEnd]) } else { nationalNumber.WriteString(numberToParse[phoneContextStart:]) } } // Now append everything between the "tel:" prefix and the // phone-context. This should include the national number, an // optional extension or isdn-subaddress component. Note we also // handle the case when "tel:" is missing, as we have seen in some // of the phone number inputs. In that case, we append everything // from the beginning. indexOfRfc3966Prefix := strings.Index(numberToParse, RFC3966_PREFIX) indexOfNationalNumber := 0 if indexOfRfc3966Prefix >= 0 { indexOfNationalNumber = indexOfRfc3966Prefix + len(RFC3966_PREFIX) } nationalNumber.WriteString( numberToParse[indexOfNationalNumber:indexOfPhoneContext]) } else { // Extract a possible number from the string passed in (this // strips leading characters that could not be the start of a // phone number.) nationalNumber.WriteString(extractPossibleNumber(numberToParse)) } // Delete the isdn-subaddress and everything after it if it is present. // Note extension won't appear at the same time with isdn-subaddress // according to paragraph 5.3 of the RFC3966 spec, indexOfIsdn := strings.Index(nationalNumber.String(), RFC3966_ISDN_SUBADDRESS) if indexOfIsdn > 0 { natNumBytes := nationalNumber.Bytes() nationalNumber.ResetWith(natNumBytes[:indexOfIsdn]) } // If both phone context and isdn-subaddress are absent but other // parameters are present, the parameters are left in nationalNumber. // This is because we are concerned about deleting content from a // potential number string when there is no strong evidence that the // number is actually written in RFC3966. }
[ "func", "buildNationalNumberForParsing", "(", "numberToParse", "string", ",", "nationalNumber", "*", "builder", ".", "Builder", ")", "{", "indexOfPhoneContext", ":=", "strings", ".", "Index", "(", "numberToParse", ",", "RFC3966_PHONE_CONTEXT", ")", "\n", "if", "indexOfPhoneContext", ">", "0", "{", "phoneContextStart", ":=", "indexOfPhoneContext", "+", "len", "(", "RFC3966_PHONE_CONTEXT", ")", "\n", "// If the phone context contains a phone number prefix, we need", "// to capture it, whereas domains will be ignored.", "if", "numberToParse", "[", "phoneContextStart", "]", "==", "PLUS_SIGN", "{", "// Additional parameters might follow the phone context. If so,", "// we will remove them here because the parameters after phone", "// context are not important for parsing the phone number.", "phoneContextEnd", ":=", "strings", ".", "Index", "(", "numberToParse", "[", "phoneContextStart", ":", "]", ",", "\"", "\"", ")", "\n", "if", "phoneContextEnd", ">", "0", "{", "nationalNumber", ".", "WriteString", "(", "numberToParse", "[", "phoneContextStart", ":", "phoneContextEnd", "]", ")", "\n", "}", "else", "{", "nationalNumber", ".", "WriteString", "(", "numberToParse", "[", "phoneContextStart", ":", "]", ")", "\n", "}", "\n", "}", "\n", "// Now append everything between the \"tel:\" prefix and the", "// phone-context. This should include the national number, an", "// optional extension or isdn-subaddress component. Note we also", "// handle the case when \"tel:\" is missing, as we have seen in some", "// of the phone number inputs. In that case, we append everything", "// from the beginning.", "indexOfRfc3966Prefix", ":=", "strings", ".", "Index", "(", "numberToParse", ",", "RFC3966_PREFIX", ")", "\n", "indexOfNationalNumber", ":=", "0", "\n", "if", "indexOfRfc3966Prefix", ">=", "0", "{", "indexOfNationalNumber", "=", "indexOfRfc3966Prefix", "+", "len", "(", "RFC3966_PREFIX", ")", "\n", "}", "\n", "nationalNumber", ".", "WriteString", "(", "numberToParse", "[", "indexOfNationalNumber", ":", "indexOfPhoneContext", "]", ")", "\n", "}", "else", "{", "// Extract a possible number from the string passed in (this", "// strips leading characters that could not be the start of a", "// phone number.)", "nationalNumber", ".", "WriteString", "(", "extractPossibleNumber", "(", "numberToParse", ")", ")", "\n", "}", "\n\n", "// Delete the isdn-subaddress and everything after it if it is present.", "// Note extension won't appear at the same time with isdn-subaddress", "// according to paragraph 5.3 of the RFC3966 spec,", "indexOfIsdn", ":=", "strings", ".", "Index", "(", "nationalNumber", ".", "String", "(", ")", ",", "RFC3966_ISDN_SUBADDRESS", ")", "\n", "if", "indexOfIsdn", ">", "0", "{", "natNumBytes", ":=", "nationalNumber", ".", "Bytes", "(", ")", "\n", "nationalNumber", ".", "ResetWith", "(", "natNumBytes", "[", ":", "indexOfIsdn", "]", ")", "\n", "}", "\n", "// If both phone context and isdn-subaddress are absent but other", "// parameters are present, the parameters are left in nationalNumber.", "// This is because we are concerned about deleting content from a", "// potential number string when there is no strong evidence that the", "// number is actually written in RFC3966.", "}" ]
// Converts numberToParse to a form that we can parse and write it to // nationalNumber if it is written in RFC3966; otherwise extract a possible // number out of it and write to nationalNumber.
[ "Converts", "numberToParse", "to", "a", "form", "that", "we", "can", "parse", "and", "write", "it", "to", "nationalNumber", "if", "it", "is", "written", "in", "RFC3966", ";", "otherwise", "extract", "a", "possible", "number", "out", "of", "it", "and", "write", "to", "nationalNumber", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L3009-L3063
35
ttacon/libphonenumber
phonenumberutil.go
isNumberMatchWithNumbers
func isNumberMatchWithNumbers(firstNumberIn, secondNumberIn *PhoneNumber) MatchType { // Make copies of the phone number so that the numbers passed in are not edited. var firstNumber, secondNumber *PhoneNumber firstNumber = &PhoneNumber{} secondNumber = &PhoneNumber{} proto.Merge(firstNumber, firstNumberIn) proto.Merge(secondNumber, secondNumberIn) // First clear raw_input, country_code_source and // preferred_domestic_carrier_code fields and any empty-string // extensions so that we can use the proto-buffer equality method. firstNumber.RawInput = nil firstNumber.CountryCodeSource = nil firstNumber.PreferredDomesticCarrierCode = nil secondNumber.RawInput = nil secondNumber.CountryCodeSource = nil secondNumber.PreferredDomesticCarrierCode = nil firstNumExt := firstNumber.GetExtension() secondNumExt := secondNumber.GetExtension() // NOTE(ttacon): don't think we need this in go land... if len(firstNumExt) == 0 { firstNumber.Extension = nil } if len(secondNumExt) == 0 { secondNumber.Extension = nil } // Early exit if both had extensions and these are different. if len(firstNumExt) > 0 && len(secondNumExt) > 0 && firstNumExt != secondNumExt { return NO_MATCH } var ( firstNumberCountryCode = firstNumber.GetCountryCode() secondNumberCountryCode = secondNumber.GetCountryCode() ) // Both had country_code specified. if firstNumberCountryCode != 0 && secondNumberCountryCode != 0 { // TODO(ttacon): remove when make gen-equals if reflect.DeepEqual(firstNumber, secondNumber) { return EXACT_MATCH } else if firstNumberCountryCode == secondNumberCountryCode && isNationalNumberSuffixOfTheOther(firstNumber, secondNumber) { // A SHORT_NSN_MATCH occurs if there is a difference because of // the presence or absence of an 'Italian leading zero', the // presence or absence of an extension, or one NSN being a // shorter variant of the other. return SHORT_NSN_MATCH } // This is not a match. return NO_MATCH } // Checks cases where one or both country_code fields were not // specified. To make equality checks easier, we first set the // country_code fields to be equal. firstNumber.CountryCode = proto.Int(int(secondNumberCountryCode)) // If all else was the same, then this is an NSN_MATCH. // TODO(ttacon): remove when make gen-equals if reflect.DeepEqual(firstNumber, secondNumber) { return NSN_MATCH } if isNationalNumberSuffixOfTheOther(firstNumber, secondNumber) { return SHORT_NSN_MATCH } return NO_MATCH }
go
func isNumberMatchWithNumbers(firstNumberIn, secondNumberIn *PhoneNumber) MatchType { // Make copies of the phone number so that the numbers passed in are not edited. var firstNumber, secondNumber *PhoneNumber firstNumber = &PhoneNumber{} secondNumber = &PhoneNumber{} proto.Merge(firstNumber, firstNumberIn) proto.Merge(secondNumber, secondNumberIn) // First clear raw_input, country_code_source and // preferred_domestic_carrier_code fields and any empty-string // extensions so that we can use the proto-buffer equality method. firstNumber.RawInput = nil firstNumber.CountryCodeSource = nil firstNumber.PreferredDomesticCarrierCode = nil secondNumber.RawInput = nil secondNumber.CountryCodeSource = nil secondNumber.PreferredDomesticCarrierCode = nil firstNumExt := firstNumber.GetExtension() secondNumExt := secondNumber.GetExtension() // NOTE(ttacon): don't think we need this in go land... if len(firstNumExt) == 0 { firstNumber.Extension = nil } if len(secondNumExt) == 0 { secondNumber.Extension = nil } // Early exit if both had extensions and these are different. if len(firstNumExt) > 0 && len(secondNumExt) > 0 && firstNumExt != secondNumExt { return NO_MATCH } var ( firstNumberCountryCode = firstNumber.GetCountryCode() secondNumberCountryCode = secondNumber.GetCountryCode() ) // Both had country_code specified. if firstNumberCountryCode != 0 && secondNumberCountryCode != 0 { // TODO(ttacon): remove when make gen-equals if reflect.DeepEqual(firstNumber, secondNumber) { return EXACT_MATCH } else if firstNumberCountryCode == secondNumberCountryCode && isNationalNumberSuffixOfTheOther(firstNumber, secondNumber) { // A SHORT_NSN_MATCH occurs if there is a difference because of // the presence or absence of an 'Italian leading zero', the // presence or absence of an extension, or one NSN being a // shorter variant of the other. return SHORT_NSN_MATCH } // This is not a match. return NO_MATCH } // Checks cases where one or both country_code fields were not // specified. To make equality checks easier, we first set the // country_code fields to be equal. firstNumber.CountryCode = proto.Int(int(secondNumberCountryCode)) // If all else was the same, then this is an NSN_MATCH. // TODO(ttacon): remove when make gen-equals if reflect.DeepEqual(firstNumber, secondNumber) { return NSN_MATCH } if isNationalNumberSuffixOfTheOther(firstNumber, secondNumber) { return SHORT_NSN_MATCH } return NO_MATCH }
[ "func", "isNumberMatchWithNumbers", "(", "firstNumberIn", ",", "secondNumberIn", "*", "PhoneNumber", ")", "MatchType", "{", "// Make copies of the phone number so that the numbers passed in are not edited.", "var", "firstNumber", ",", "secondNumber", "*", "PhoneNumber", "\n", "firstNumber", "=", "&", "PhoneNumber", "{", "}", "\n", "secondNumber", "=", "&", "PhoneNumber", "{", "}", "\n", "proto", ".", "Merge", "(", "firstNumber", ",", "firstNumberIn", ")", "\n", "proto", ".", "Merge", "(", "secondNumber", ",", "secondNumberIn", ")", "\n", "// First clear raw_input, country_code_source and", "// preferred_domestic_carrier_code fields and any empty-string", "// extensions so that we can use the proto-buffer equality method.", "firstNumber", ".", "RawInput", "=", "nil", "\n", "firstNumber", ".", "CountryCodeSource", "=", "nil", "\n", "firstNumber", ".", "PreferredDomesticCarrierCode", "=", "nil", "\n", "secondNumber", ".", "RawInput", "=", "nil", "\n", "secondNumber", ".", "CountryCodeSource", "=", "nil", "\n", "secondNumber", ".", "PreferredDomesticCarrierCode", "=", "nil", "\n\n", "firstNumExt", ":=", "firstNumber", ".", "GetExtension", "(", ")", "\n", "secondNumExt", ":=", "secondNumber", ".", "GetExtension", "(", ")", "\n", "// NOTE(ttacon): don't think we need this in go land...", "if", "len", "(", "firstNumExt", ")", "==", "0", "{", "firstNumber", ".", "Extension", "=", "nil", "\n", "}", "\n", "if", "len", "(", "secondNumExt", ")", "==", "0", "{", "secondNumber", ".", "Extension", "=", "nil", "\n", "}", "\n\n", "// Early exit if both had extensions and these are different.", "if", "len", "(", "firstNumExt", ")", ">", "0", "&&", "len", "(", "secondNumExt", ")", ">", "0", "&&", "firstNumExt", "!=", "secondNumExt", "{", "return", "NO_MATCH", "\n", "}", "\n", "var", "(", "firstNumberCountryCode", "=", "firstNumber", ".", "GetCountryCode", "(", ")", "\n", "secondNumberCountryCode", "=", "secondNumber", ".", "GetCountryCode", "(", ")", "\n", ")", "\n", "// Both had country_code specified.", "if", "firstNumberCountryCode", "!=", "0", "&&", "secondNumberCountryCode", "!=", "0", "{", "// TODO(ttacon): remove when make gen-equals", "if", "reflect", ".", "DeepEqual", "(", "firstNumber", ",", "secondNumber", ")", "{", "return", "EXACT_MATCH", "\n", "}", "else", "if", "firstNumberCountryCode", "==", "secondNumberCountryCode", "&&", "isNationalNumberSuffixOfTheOther", "(", "firstNumber", ",", "secondNumber", ")", "{", "// A SHORT_NSN_MATCH occurs if there is a difference because of", "// the presence or absence of an 'Italian leading zero', the", "// presence or absence of an extension, or one NSN being a", "// shorter variant of the other.", "return", "SHORT_NSN_MATCH", "\n", "}", "\n", "// This is not a match.", "return", "NO_MATCH", "\n", "}", "\n", "// Checks cases where one or both country_code fields were not", "// specified. To make equality checks easier, we first set the", "// country_code fields to be equal.", "firstNumber", ".", "CountryCode", "=", "proto", ".", "Int", "(", "int", "(", "secondNumberCountryCode", ")", ")", "\n", "// If all else was the same, then this is an NSN_MATCH.", "// TODO(ttacon): remove when make gen-equals", "if", "reflect", ".", "DeepEqual", "(", "firstNumber", ",", "secondNumber", ")", "{", "return", "NSN_MATCH", "\n", "}", "\n", "if", "isNationalNumberSuffixOfTheOther", "(", "firstNumber", ",", "secondNumber", ")", "{", "return", "SHORT_NSN_MATCH", "\n", "}", "\n", "return", "NO_MATCH", "\n", "}" ]
// Takes two phone numbers and compares them for equality. // // Returns EXACT_MATCH if the country_code, NSN, presence of a leading zero // for Italian numbers and any extension present are the same. // Returns NSN_MATCH if either or both has no region specified, and the NSNs // and extensions are the same. // Returns SHORT_NSN_MATCH if either or both has no region specified, or the // region specified is the same, and one NSN could be a shorter version of // the other number. This includes the case where one has an extension // specified, and the other does not. // Returns NO_MATCH otherwise. // For example, the numbers +1 345 657 1234 and 657 1234 are a SHORT_NSN_MATCH. // The numbers +1 345 657 1234 and 345 657 are a NO_MATCH.
[ "Takes", "two", "phone", "numbers", "and", "compares", "them", "for", "equality", ".", "Returns", "EXACT_MATCH", "if", "the", "country_code", "NSN", "presence", "of", "a", "leading", "zero", "for", "Italian", "numbers", "and", "any", "extension", "present", "are", "the", "same", ".", "Returns", "NSN_MATCH", "if", "either", "or", "both", "has", "no", "region", "specified", "and", "the", "NSNs", "and", "extensions", "are", "the", "same", ".", "Returns", "SHORT_NSN_MATCH", "if", "either", "or", "both", "has", "no", "region", "specified", "or", "the", "region", "specified", "is", "the", "same", "and", "one", "NSN", "could", "be", "a", "shorter", "version", "of", "the", "other", "number", ".", "This", "includes", "the", "case", "where", "one", "has", "an", "extension", "specified", "and", "the", "other", "does", "not", ".", "Returns", "NO_MATCH", "otherwise", ".", "For", "example", "the", "numbers", "+", "1", "345", "657", "1234", "and", "657", "1234", "are", "a", "SHORT_NSN_MATCH", ".", "The", "numbers", "+", "1", "345", "657", "1234", "and", "345", "657", "are", "a", "NO_MATCH", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L3078-L3143
36
ttacon/libphonenumber
phonenumberutil.go
isNationalNumberSuffixOfTheOther
func isNationalNumberSuffixOfTheOther(firstNumber, secondNumber *PhoneNumber) bool { var ( firstNumberNationalNumber = strconv.FormatUint( firstNumber.GetNationalNumber(), 10) secondNumberNationalNumber = strconv.FormatUint( secondNumber.GetNationalNumber(), 10) ) // Note that endsWith returns true if the numbers are equal. return strings.HasSuffix(firstNumberNationalNumber, secondNumberNationalNumber) || strings.HasSuffix(secondNumberNationalNumber, firstNumberNationalNumber) }
go
func isNationalNumberSuffixOfTheOther(firstNumber, secondNumber *PhoneNumber) bool { var ( firstNumberNationalNumber = strconv.FormatUint( firstNumber.GetNationalNumber(), 10) secondNumberNationalNumber = strconv.FormatUint( secondNumber.GetNationalNumber(), 10) ) // Note that endsWith returns true if the numbers are equal. return strings.HasSuffix(firstNumberNationalNumber, secondNumberNationalNumber) || strings.HasSuffix(secondNumberNationalNumber, firstNumberNationalNumber) }
[ "func", "isNationalNumberSuffixOfTheOther", "(", "firstNumber", ",", "secondNumber", "*", "PhoneNumber", ")", "bool", "{", "var", "(", "firstNumberNationalNumber", "=", "strconv", ".", "FormatUint", "(", "firstNumber", ".", "GetNationalNumber", "(", ")", ",", "10", ")", "\n", "secondNumberNationalNumber", "=", "strconv", ".", "FormatUint", "(", "secondNumber", ".", "GetNationalNumber", "(", ")", ",", "10", ")", "\n", ")", "\n", "// Note that endsWith returns true if the numbers are equal.", "return", "strings", ".", "HasSuffix", "(", "firstNumberNationalNumber", ",", "secondNumberNationalNumber", ")", "||", "strings", ".", "HasSuffix", "(", "secondNumberNationalNumber", ",", "firstNumberNationalNumber", ")", "\n", "}" ]
// Returns true when one national number is the suffix of the other or both // are the same.
[ "Returns", "true", "when", "one", "national", "number", "is", "the", "suffix", "of", "the", "other", "or", "both", "are", "the", "same", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L3147-L3157
37
ttacon/libphonenumber
phonenumberutil.go
IsMobileNumberPortableRegion
func IsMobileNumberPortableRegion(regionCode string) bool { metadata := getMetadataForRegion(regionCode) if metadata == nil { return false } return metadata.GetMobileNumberPortableRegion() }
go
func IsMobileNumberPortableRegion(regionCode string) bool { metadata := getMetadataForRegion(regionCode) if metadata == nil { return false } return metadata.GetMobileNumberPortableRegion() }
[ "func", "IsMobileNumberPortableRegion", "(", "regionCode", "string", ")", "bool", "{", "metadata", ":=", "getMetadataForRegion", "(", "regionCode", ")", "\n", "if", "metadata", "==", "nil", "{", "return", "false", "\n", "}", "\n", "return", "metadata", ".", "GetMobileNumberPortableRegion", "(", ")", "\n", "}" ]
// Returns true if the supplied region supports mobile number portability. // Returns false for invalid, unknown or regions that don't support mobile // number portability.
[ "Returns", "true", "if", "the", "supplied", "region", "supports", "mobile", "number", "portability", ".", "Returns", "false", "for", "invalid", "unknown", "or", "regions", "that", "don", "t", "support", "mobile", "number", "portability", "." ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L3254-L3260
38
ttacon/libphonenumber
countryCodeToTimeZones.go
GetTimeZonesForRegion
func GetTimeZonesForRegion(number string) ([]string, error) { for i := MAX_REGION_CODE_LENGTH; i > 0; i-- { index, err := strconv.Atoi(number[0:i]) if err != nil { return nil, err } if CountryCodeToTimeZones[index] != nil { return CountryCodeToTimeZones[index], nil } } return []string{UNKNOWN_TIMEZONE}, nil }
go
func GetTimeZonesForRegion(number string) ([]string, error) { for i := MAX_REGION_CODE_LENGTH; i > 0; i-- { index, err := strconv.Atoi(number[0:i]) if err != nil { return nil, err } if CountryCodeToTimeZones[index] != nil { return CountryCodeToTimeZones[index], nil } } return []string{UNKNOWN_TIMEZONE}, nil }
[ "func", "GetTimeZonesForRegion", "(", "number", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "for", "i", ":=", "MAX_REGION_CODE_LENGTH", ";", "i", ">", "0", ";", "i", "--", "{", "index", ",", "err", ":=", "strconv", ".", "Atoi", "(", "number", "[", "0", ":", "i", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "CountryCodeToTimeZones", "[", "index", "]", "!=", "nil", "{", "return", "CountryCodeToTimeZones", "[", "index", "]", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "[", "]", "string", "{", "UNKNOWN_TIMEZONE", "}", ",", "nil", "\n", "}" ]
// Returns a slice of Timezones corresponding to the number passed // or error when it is impossible to convert the string to int // The algorythm tries to match the timezones starting from the maximum // number of phone number digits and decreasing until it finds one or reaches 0
[ "Returns", "a", "slice", "of", "Timezones", "corresponding", "to", "the", "number", "passed", "or", "error", "when", "it", "is", "impossible", "to", "convert", "the", "string", "to", "int", "The", "algorythm", "tries", "to", "match", "the", "timezones", "starting", "from", "the", "maximum", "number", "of", "phone", "number", "digits", "and", "decreasing", "until", "it", "finds", "one", "or", "reaches", "0" ]
23ddf903e8f8800d2857645eb155ffbe15cd02ee
https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/countryCodeToTimeZones.go#L2253-L2264
39
hajimehoshi/go-mp3
decode.go
Read
func (d *Decoder) Read(buf []byte) (int, error) { for len(d.buf) == 0 { if err := d.readFrame(); err != nil { return 0, err } } n := copy(buf, d.buf) d.buf = d.buf[n:] d.pos += int64(n) return n, nil }
go
func (d *Decoder) Read(buf []byte) (int, error) { for len(d.buf) == 0 { if err := d.readFrame(); err != nil { return 0, err } } n := copy(buf, d.buf) d.buf = d.buf[n:] d.pos += int64(n) return n, nil }
[ "func", "(", "d", "*", "Decoder", ")", "Read", "(", "buf", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "for", "len", "(", "d", ".", "buf", ")", "==", "0", "{", "if", "err", ":=", "d", ".", "readFrame", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "}", "\n", "n", ":=", "copy", "(", "buf", ",", "d", ".", "buf", ")", "\n", "d", ".", "buf", "=", "d", ".", "buf", "[", "n", ":", "]", "\n", "d", ".", "pos", "+=", "int64", "(", "n", ")", "\n", "return", "n", ",", "nil", "\n", "}" ]
// Read is io.Reader's Read.
[ "Read", "is", "io", ".", "Reader", "s", "Read", "." ]
14af46a99b16fe1e285e22e032579d8b075c71f4
https://github.com/hajimehoshi/go-mp3/blob/14af46a99b16fe1e285e22e032579d8b075c71f4/decode.go#L57-L67
40
hajimehoshi/go-mp3
decode.go
Seek
func (d *Decoder) Seek(offset int64, whence int) (int64, error) { npos := int64(0) switch whence { case io.SeekStart: npos = offset case io.SeekCurrent: npos = d.pos + offset case io.SeekEnd: npos = d.Length() + offset default: panic(fmt.Sprintf("mp3: invalid whence: %v", whence)) } d.pos = npos d.buf = nil d.frame = nil f := d.pos / consts.BytesPerFrame // If the frame is not first, read the previous ahead of reading that // because the previous frame can affect the targeted frame. if f > 0 { f-- if _, err := d.source.Seek(d.frameStarts[f], 0); err != nil { return 0, err } if err := d.readFrame(); err != nil { return 0, err } if err := d.readFrame(); err != nil { return 0, err } d.buf = d.buf[consts.BytesPerFrame+(d.pos%consts.BytesPerFrame):] } else { if _, err := d.source.Seek(d.frameStarts[f], 0); err != nil { return 0, err } if err := d.readFrame(); err != nil { return 0, err } d.buf = d.buf[d.pos:] } return npos, nil }
go
func (d *Decoder) Seek(offset int64, whence int) (int64, error) { npos := int64(0) switch whence { case io.SeekStart: npos = offset case io.SeekCurrent: npos = d.pos + offset case io.SeekEnd: npos = d.Length() + offset default: panic(fmt.Sprintf("mp3: invalid whence: %v", whence)) } d.pos = npos d.buf = nil d.frame = nil f := d.pos / consts.BytesPerFrame // If the frame is not first, read the previous ahead of reading that // because the previous frame can affect the targeted frame. if f > 0 { f-- if _, err := d.source.Seek(d.frameStarts[f], 0); err != nil { return 0, err } if err := d.readFrame(); err != nil { return 0, err } if err := d.readFrame(); err != nil { return 0, err } d.buf = d.buf[consts.BytesPerFrame+(d.pos%consts.BytesPerFrame):] } else { if _, err := d.source.Seek(d.frameStarts[f], 0); err != nil { return 0, err } if err := d.readFrame(); err != nil { return 0, err } d.buf = d.buf[d.pos:] } return npos, nil }
[ "func", "(", "d", "*", "Decoder", ")", "Seek", "(", "offset", "int64", ",", "whence", "int", ")", "(", "int64", ",", "error", ")", "{", "npos", ":=", "int64", "(", "0", ")", "\n", "switch", "whence", "{", "case", "io", ".", "SeekStart", ":", "npos", "=", "offset", "\n", "case", "io", ".", "SeekCurrent", ":", "npos", "=", "d", ".", "pos", "+", "offset", "\n", "case", "io", ".", "SeekEnd", ":", "npos", "=", "d", ".", "Length", "(", ")", "+", "offset", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "whence", ")", ")", "\n", "}", "\n", "d", ".", "pos", "=", "npos", "\n", "d", ".", "buf", "=", "nil", "\n", "d", ".", "frame", "=", "nil", "\n", "f", ":=", "d", ".", "pos", "/", "consts", ".", "BytesPerFrame", "\n", "// If the frame is not first, read the previous ahead of reading that", "// because the previous frame can affect the targeted frame.", "if", "f", ">", "0", "{", "f", "--", "\n", "if", "_", ",", "err", ":=", "d", ".", "source", ".", "Seek", "(", "d", ".", "frameStarts", "[", "f", "]", ",", "0", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "err", ":=", "d", ".", "readFrame", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "err", ":=", "d", ".", "readFrame", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "d", ".", "buf", "=", "d", ".", "buf", "[", "consts", ".", "BytesPerFrame", "+", "(", "d", ".", "pos", "%", "consts", ".", "BytesPerFrame", ")", ":", "]", "\n", "}", "else", "{", "if", "_", ",", "err", ":=", "d", ".", "source", ".", "Seek", "(", "d", ".", "frameStarts", "[", "f", "]", ",", "0", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "err", ":=", "d", ".", "readFrame", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "d", ".", "buf", "=", "d", ".", "buf", "[", "d", ".", "pos", ":", "]", "\n", "}", "\n", "return", "npos", ",", "nil", "\n", "}" ]
// Seek is io.Seeker's Seek. // // Seek panics when the underlying source is not io.Seeker.
[ "Seek", "is", "io", ".", "Seeker", "s", "Seek", ".", "Seek", "panics", "when", "the", "underlying", "source", "is", "not", "io", ".", "Seeker", "." ]
14af46a99b16fe1e285e22e032579d8b075c71f4
https://github.com/hajimehoshi/go-mp3/blob/14af46a99b16fe1e285e22e032579d8b075c71f4/decode.go#L72-L112
41
hajimehoshi/go-mp3
internal/frameheader/frameheader.go
IsValid
func (f FrameHeader) IsValid() bool { const sync = 0xffe00000 if (f & sync) != sync { return false } if f.ID() == consts.VersionReserved { return false } if f.BitrateIndex() == 15 { return false } if f.SamplingFrequency() == consts.SamplingFrequencyReserved { return false } if f.Layer() == consts.LayerReserved { return false } if f.Emphasis() == 2 { return false } return true }
go
func (f FrameHeader) IsValid() bool { const sync = 0xffe00000 if (f & sync) != sync { return false } if f.ID() == consts.VersionReserved { return false } if f.BitrateIndex() == 15 { return false } if f.SamplingFrequency() == consts.SamplingFrequencyReserved { return false } if f.Layer() == consts.LayerReserved { return false } if f.Emphasis() == 2 { return false } return true }
[ "func", "(", "f", "FrameHeader", ")", "IsValid", "(", ")", "bool", "{", "const", "sync", "=", "0xffe00000", "\n", "if", "(", "f", "&", "sync", ")", "!=", "sync", "{", "return", "false", "\n", "}", "\n", "if", "f", ".", "ID", "(", ")", "==", "consts", ".", "VersionReserved", "{", "return", "false", "\n", "}", "\n", "if", "f", ".", "BitrateIndex", "(", ")", "==", "15", "{", "return", "false", "\n", "}", "\n", "if", "f", ".", "SamplingFrequency", "(", ")", "==", "consts", ".", "SamplingFrequencyReserved", "{", "return", "false", "\n", "}", "\n", "if", "f", ".", "Layer", "(", ")", "==", "consts", ".", "LayerReserved", "{", "return", "false", "\n", "}", "\n", "if", "f", ".", "Emphasis", "(", ")", "==", "2", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]
// IsValid returns a boolean value indicating whether the header is valid or not.
[ "IsValid", "returns", "a", "boolean", "value", "indicating", "whether", "the", "header", "is", "valid", "or", "not", "." ]
14af46a99b16fe1e285e22e032579d8b075c71f4
https://github.com/hajimehoshi/go-mp3/blob/14af46a99b16fe1e285e22e032579d8b075c71f4/internal/frameheader/frameheader.go#L105-L126
42
seiflotfy/cuckoofilter
cuckoofilter.go
NewFilter
func NewFilter(capacity uint) *Filter { capacity = getNextPow2(uint64(capacity)) / bucketSize if capacity == 0 { capacity = 1 } buckets := make([]bucket, capacity) for i := range buckets { buckets[i] = [bucketSize]byte{} } return &Filter{buckets, 0} }
go
func NewFilter(capacity uint) *Filter { capacity = getNextPow2(uint64(capacity)) / bucketSize if capacity == 0 { capacity = 1 } buckets := make([]bucket, capacity) for i := range buckets { buckets[i] = [bucketSize]byte{} } return &Filter{buckets, 0} }
[ "func", "NewFilter", "(", "capacity", "uint", ")", "*", "Filter", "{", "capacity", "=", "getNextPow2", "(", "uint64", "(", "capacity", ")", ")", "/", "bucketSize", "\n", "if", "capacity", "==", "0", "{", "capacity", "=", "1", "\n", "}", "\n", "buckets", ":=", "make", "(", "[", "]", "bucket", ",", "capacity", ")", "\n", "for", "i", ":=", "range", "buckets", "{", "buckets", "[", "i", "]", "=", "[", "bucketSize", "]", "byte", "{", "}", "\n", "}", "\n", "return", "&", "Filter", "{", "buckets", ",", "0", "}", "\n", "}" ]
// NewFilter returns a new cuckoofilter with a given capacity. // A capacity of 1000000 is a normal default, which allocates // about ~1MB on 64-bit machines.
[ "NewFilter", "returns", "a", "new", "cuckoofilter", "with", "a", "given", "capacity", ".", "A", "capacity", "of", "1000000", "is", "a", "normal", "default", "which", "allocates", "about", "~1MB", "on", "64", "-", "bit", "machines", "." ]
764cb5258d9bcd276f2f809e74cfa206d8e8e054
https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L19-L29
43
seiflotfy/cuckoofilter
cuckoofilter.go
Lookup
func (cf *Filter) Lookup(data []byte) bool { i1, i2, fp := getIndicesAndFingerprint(data, uint(len(cf.buckets))) b1, b2 := cf.buckets[i1], cf.buckets[i2] return b1.getFingerprintIndex(fp) > -1 || b2.getFingerprintIndex(fp) > -1 }
go
func (cf *Filter) Lookup(data []byte) bool { i1, i2, fp := getIndicesAndFingerprint(data, uint(len(cf.buckets))) b1, b2 := cf.buckets[i1], cf.buckets[i2] return b1.getFingerprintIndex(fp) > -1 || b2.getFingerprintIndex(fp) > -1 }
[ "func", "(", "cf", "*", "Filter", ")", "Lookup", "(", "data", "[", "]", "byte", ")", "bool", "{", "i1", ",", "i2", ",", "fp", ":=", "getIndicesAndFingerprint", "(", "data", ",", "uint", "(", "len", "(", "cf", ".", "buckets", ")", ")", ")", "\n", "b1", ",", "b2", ":=", "cf", ".", "buckets", "[", "i1", "]", ",", "cf", ".", "buckets", "[", "i2", "]", "\n", "return", "b1", ".", "getFingerprintIndex", "(", "fp", ")", ">", "-", "1", "||", "b2", ".", "getFingerprintIndex", "(", "fp", ")", ">", "-", "1", "\n", "}" ]
// Lookup returns true if data is in the counter
[ "Lookup", "returns", "true", "if", "data", "is", "in", "the", "counter" ]
764cb5258d9bcd276f2f809e74cfa206d8e8e054
https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L32-L36
44
seiflotfy/cuckoofilter
cuckoofilter.go
Insert
func (cf *Filter) Insert(data []byte) bool { i1, i2, fp := getIndicesAndFingerprint(data, uint(len(cf.buckets))) if cf.insert(fp, i1) || cf.insert(fp, i2) { return true } return cf.reinsert(fp, randi(i1, i2)) }
go
func (cf *Filter) Insert(data []byte) bool { i1, i2, fp := getIndicesAndFingerprint(data, uint(len(cf.buckets))) if cf.insert(fp, i1) || cf.insert(fp, i2) { return true } return cf.reinsert(fp, randi(i1, i2)) }
[ "func", "(", "cf", "*", "Filter", ")", "Insert", "(", "data", "[", "]", "byte", ")", "bool", "{", "i1", ",", "i2", ",", "fp", ":=", "getIndicesAndFingerprint", "(", "data", ",", "uint", "(", "len", "(", "cf", ".", "buckets", ")", ")", ")", "\n", "if", "cf", ".", "insert", "(", "fp", ",", "i1", ")", "||", "cf", ".", "insert", "(", "fp", ",", "i2", ")", "{", "return", "true", "\n", "}", "\n", "return", "cf", ".", "reinsert", "(", "fp", ",", "randi", "(", "i1", ",", "i2", ")", ")", "\n", "}" ]
// Insert inserts data into the counter and returns true upon success
[ "Insert", "inserts", "data", "into", "the", "counter", "and", "returns", "true", "upon", "success" ]
764cb5258d9bcd276f2f809e74cfa206d8e8e054
https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L53-L59
45
seiflotfy/cuckoofilter
cuckoofilter.go
InsertUnique
func (cf *Filter) InsertUnique(data []byte) bool { if cf.Lookup(data) { return false } return cf.Insert(data) }
go
func (cf *Filter) InsertUnique(data []byte) bool { if cf.Lookup(data) { return false } return cf.Insert(data) }
[ "func", "(", "cf", "*", "Filter", ")", "InsertUnique", "(", "data", "[", "]", "byte", ")", "bool", "{", "if", "cf", ".", "Lookup", "(", "data", ")", "{", "return", "false", "\n", "}", "\n", "return", "cf", ".", "Insert", "(", "data", ")", "\n", "}" ]
// InsertUnique inserts data into the counter if not exists and returns true upon success
[ "InsertUnique", "inserts", "data", "into", "the", "counter", "if", "not", "exists", "and", "returns", "true", "upon", "success" ]
764cb5258d9bcd276f2f809e74cfa206d8e8e054
https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L62-L67
46
seiflotfy/cuckoofilter
cuckoofilter.go
Delete
func (cf *Filter) Delete(data []byte) bool { i1, i2, fp := getIndicesAndFingerprint(data, uint(len(cf.buckets))) return cf.delete(fp, i1) || cf.delete(fp, i2) }
go
func (cf *Filter) Delete(data []byte) bool { i1, i2, fp := getIndicesAndFingerprint(data, uint(len(cf.buckets))) return cf.delete(fp, i1) || cf.delete(fp, i2) }
[ "func", "(", "cf", "*", "Filter", ")", "Delete", "(", "data", "[", "]", "byte", ")", "bool", "{", "i1", ",", "i2", ",", "fp", ":=", "getIndicesAndFingerprint", "(", "data", ",", "uint", "(", "len", "(", "cf", ".", "buckets", ")", ")", ")", "\n", "return", "cf", ".", "delete", "(", "fp", ",", "i1", ")", "||", "cf", ".", "delete", "(", "fp", ",", "i2", ")", "\n", "}" ]
// Delete data from counter if exists and return if deleted or not
[ "Delete", "data", "from", "counter", "if", "exists", "and", "return", "if", "deleted", "or", "not" ]
764cb5258d9bcd276f2f809e74cfa206d8e8e054
https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L94-L97
47
seiflotfy/cuckoofilter
cuckoofilter.go
Encode
func (cf *Filter) Encode() []byte { bytes := make([]byte, len(cf.buckets)*bucketSize) for i, b := range cf.buckets { for j, f := range b { index := (i * len(b)) + j bytes[index] = f } } return bytes }
go
func (cf *Filter) Encode() []byte { bytes := make([]byte, len(cf.buckets)*bucketSize) for i, b := range cf.buckets { for j, f := range b { index := (i * len(b)) + j bytes[index] = f } } return bytes }
[ "func", "(", "cf", "*", "Filter", ")", "Encode", "(", ")", "[", "]", "byte", "{", "bytes", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "cf", ".", "buckets", ")", "*", "bucketSize", ")", "\n", "for", "i", ",", "b", ":=", "range", "cf", ".", "buckets", "{", "for", "j", ",", "f", ":=", "range", "b", "{", "index", ":=", "(", "i", "*", "len", "(", "b", ")", ")", "+", "j", "\n", "bytes", "[", "index", "]", "=", "f", "\n", "}", "\n", "}", "\n", "return", "bytes", "\n", "}" ]
// Encode returns a byte slice representing a Cuckoofilter
[ "Encode", "returns", "a", "byte", "slice", "representing", "a", "Cuckoofilter" ]
764cb5258d9bcd276f2f809e74cfa206d8e8e054
https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L113-L122
48
seiflotfy/cuckoofilter
cuckoofilter.go
Decode
func Decode(bytes []byte) (*Filter, error) { var count uint if len(bytes)%bucketSize != 0 { return nil, fmt.Errorf("expected bytes to be multiple of %d, got %d", bucketSize, len(bytes)) } buckets := make([]bucket, len(bytes)/4) for i, b := range buckets { for j := range b { index := (i * len(b)) + j if bytes[index] != 0 { buckets[i][j] = bytes[index] count++ } } } return &Filter{ buckets: buckets, count: count, }, nil }
go
func Decode(bytes []byte) (*Filter, error) { var count uint if len(bytes)%bucketSize != 0 { return nil, fmt.Errorf("expected bytes to be multiple of %d, got %d", bucketSize, len(bytes)) } buckets := make([]bucket, len(bytes)/4) for i, b := range buckets { for j := range b { index := (i * len(b)) + j if bytes[index] != 0 { buckets[i][j] = bytes[index] count++ } } } return &Filter{ buckets: buckets, count: count, }, nil }
[ "func", "Decode", "(", "bytes", "[", "]", "byte", ")", "(", "*", "Filter", ",", "error", ")", "{", "var", "count", "uint", "\n", "if", "len", "(", "bytes", ")", "%", "bucketSize", "!=", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "bucketSize", ",", "len", "(", "bytes", ")", ")", "\n", "}", "\n", "buckets", ":=", "make", "(", "[", "]", "bucket", ",", "len", "(", "bytes", ")", "/", "4", ")", "\n", "for", "i", ",", "b", ":=", "range", "buckets", "{", "for", "j", ":=", "range", "b", "{", "index", ":=", "(", "i", "*", "len", "(", "b", ")", ")", "+", "j", "\n", "if", "bytes", "[", "index", "]", "!=", "0", "{", "buckets", "[", "i", "]", "[", "j", "]", "=", "bytes", "[", "index", "]", "\n", "count", "++", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "&", "Filter", "{", "buckets", ":", "buckets", ",", "count", ":", "count", ",", "}", ",", "nil", "\n", "}" ]
// Decode returns a Cuckoofilter from a byte slice
[ "Decode", "returns", "a", "Cuckoofilter", "from", "a", "byte", "slice" ]
764cb5258d9bcd276f2f809e74cfa206d8e8e054
https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L125-L144
49
seiflotfy/cuckoofilter
util.go
getIndicesAndFingerprint
func getIndicesAndFingerprint(data []byte, numBuckets uint) (uint, uint, byte) { hash := metro.Hash64(data, 1337) f := getFingerprint(data) i1 := uint(hash) % numBuckets i2 := getAltIndex(f, i1, numBuckets) return i1, i2, f }
go
func getIndicesAndFingerprint(data []byte, numBuckets uint) (uint, uint, byte) { hash := metro.Hash64(data, 1337) f := getFingerprint(data) i1 := uint(hash) % numBuckets i2 := getAltIndex(f, i1, numBuckets) return i1, i2, f }
[ "func", "getIndicesAndFingerprint", "(", "data", "[", "]", "byte", ",", "numBuckets", "uint", ")", "(", "uint", ",", "uint", ",", "byte", ")", "{", "hash", ":=", "metro", ".", "Hash64", "(", "data", ",", "1337", ")", "\n", "f", ":=", "getFingerprint", "(", "data", ")", "\n", "i1", ":=", "uint", "(", "hash", ")", "%", "numBuckets", "\n", "i2", ":=", "getAltIndex", "(", "f", ",", "i1", ",", "numBuckets", ")", "\n", "return", "i1", ",", "i2", ",", "f", "\n", "}" ]
// getIndicesAndFingerprint returns the 2 bucket indices and fingerprint to be used
[ "getIndicesAndFingerprint", "returns", "the", "2", "bucket", "indices", "and", "fingerprint", "to", "be", "used" ]
764cb5258d9bcd276f2f809e74cfa206d8e8e054
https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/util.go#L18-L24
50
markbates/grift
grift/grift.go
Namespace
func Namespace(name string, s func()) error { defer func() { namespace = "" }() namespace = applyNamespace(name) s() return nil }
go
func Namespace(name string, s func()) error { defer func() { namespace = "" }() namespace = applyNamespace(name) s() return nil }
[ "func", "Namespace", "(", "name", "string", ",", "s", "func", "(", ")", ")", "error", "{", "defer", "func", "(", ")", "{", "namespace", "=", "\"", "\"", "\n", "}", "(", ")", "\n\n", "namespace", "=", "applyNamespace", "(", "name", ")", "\n", "s", "(", ")", "\n", "return", "nil", "\n", "}" ]
// Namespace will place all tasks within the given prefix.
[ "Namespace", "will", "place", "all", "tasks", "within", "the", "given", "prefix", "." ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L24-L32
51
markbates/grift
grift/grift.go
Add
func Add(name string, grift Grift) error { lock.Lock() defer lock.Unlock() name = applyNamespace(name) if griftList[name] != nil { fn := griftList[name] griftList[name] = func(c *Context) error { err := fn(c) if err != nil { return err } return grift(c) } } else { griftList[name] = grift } return nil }
go
func Add(name string, grift Grift) error { lock.Lock() defer lock.Unlock() name = applyNamespace(name) if griftList[name] != nil { fn := griftList[name] griftList[name] = func(c *Context) error { err := fn(c) if err != nil { return err } return grift(c) } } else { griftList[name] = grift } return nil }
[ "func", "Add", "(", "name", "string", ",", "grift", "Grift", ")", "error", "{", "lock", ".", "Lock", "(", ")", "\n", "defer", "lock", ".", "Unlock", "(", ")", "\n\n", "name", "=", "applyNamespace", "(", "name", ")", "\n\n", "if", "griftList", "[", "name", "]", "!=", "nil", "{", "fn", ":=", "griftList", "[", "name", "]", "\n", "griftList", "[", "name", "]", "=", "func", "(", "c", "*", "Context", ")", "error", "{", "err", ":=", "fn", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "grift", "(", "c", ")", "\n", "}", "\n", "}", "else", "{", "griftList", "[", "name", "]", "=", "grift", "\n", "}", "\n", "return", "nil", "\n", "}" ]
// Add a grift. If there is already a grift // with the given name the two grifts will // be bundled together.
[ "Add", "a", "grift", ".", "If", "there", "is", "already", "a", "grift", "with", "the", "given", "name", "the", "two", "grifts", "will", "be", "bundled", "together", "." ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L51-L70
52
markbates/grift
grift/grift.go
Set
func Set(name string, grift Grift) error { lock.Lock() defer lock.Unlock() name = applyNamespace(name) griftList[name] = grift return nil }
go
func Set(name string, grift Grift) error { lock.Lock() defer lock.Unlock() name = applyNamespace(name) griftList[name] = grift return nil }
[ "func", "Set", "(", "name", "string", ",", "grift", "Grift", ")", "error", "{", "lock", ".", "Lock", "(", ")", "\n", "defer", "lock", ".", "Unlock", "(", ")", "\n", "name", "=", "applyNamespace", "(", "name", ")", "\n", "griftList", "[", "name", "]", "=", "grift", "\n", "return", "nil", "\n", "}" ]
// Set a grift. This is similar to `Add` but it will // overwrite an existing grift with the same name.
[ "Set", "a", "grift", ".", "This", "is", "similar", "to", "Add", "but", "it", "will", "overwrite", "an", "existing", "grift", "with", "the", "same", "name", "." ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L74-L80
53
markbates/grift
grift/grift.go
Rename
func Rename(oldName string, newName string) error { lock.Lock() defer lock.Unlock() oldName = applyNamespace(oldName) newName = applyNamespace(newName) if griftList[oldName] == nil { return fmt.Errorf("No task named %s defined!", oldName) } griftList[newName] = griftList[oldName] delete(griftList, oldName) return nil }
go
func Rename(oldName string, newName string) error { lock.Lock() defer lock.Unlock() oldName = applyNamespace(oldName) newName = applyNamespace(newName) if griftList[oldName] == nil { return fmt.Errorf("No task named %s defined!", oldName) } griftList[newName] = griftList[oldName] delete(griftList, oldName) return nil }
[ "func", "Rename", "(", "oldName", "string", ",", "newName", "string", ")", "error", "{", "lock", ".", "Lock", "(", ")", "\n", "defer", "lock", ".", "Unlock", "(", ")", "\n\n", "oldName", "=", "applyNamespace", "(", "oldName", ")", "\n", "newName", "=", "applyNamespace", "(", "newName", ")", "\n\n", "if", "griftList", "[", "oldName", "]", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "oldName", ")", "\n", "}", "\n", "griftList", "[", "newName", "]", "=", "griftList", "[", "oldName", "]", "\n", "delete", "(", "griftList", ",", "oldName", ")", "\n", "return", "nil", "\n", "}" ]
// Rename a grift. Useful if you want to re-define // an existing grift, but don't want to write over // the original.
[ "Rename", "a", "grift", ".", "Useful", "if", "you", "want", "to", "re", "-", "define", "an", "existing", "grift", "but", "don", "t", "want", "to", "write", "over", "the", "original", "." ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L85-L98
54
markbates/grift
grift/grift.go
Remove
func Remove(name string) error { lock.Lock() defer lock.Unlock() name = applyNamespace(name) delete(griftList, name) delete(descriptions, name) return nil }
go
func Remove(name string) error { lock.Lock() defer lock.Unlock() name = applyNamespace(name) delete(griftList, name) delete(descriptions, name) return nil }
[ "func", "Remove", "(", "name", "string", ")", "error", "{", "lock", ".", "Lock", "(", ")", "\n", "defer", "lock", ".", "Unlock", "(", ")", "\n\n", "name", "=", "applyNamespace", "(", "name", ")", "\n\n", "delete", "(", "griftList", ",", "name", ")", "\n", "delete", "(", "descriptions", ",", "name", ")", "\n", "return", "nil", "\n", "}" ]
// Remove a grift. Not incredibly useful, but here for // completeness.
[ "Remove", "a", "grift", ".", "Not", "incredibly", "useful", "but", "here", "for", "completeness", "." ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L102-L111
55
markbates/grift
grift/grift.go
Desc
func Desc(name string, description string) error { lock.Lock() defer lock.Unlock() name = applyNamespace(name) descriptions[name] = description return nil }
go
func Desc(name string, description string) error { lock.Lock() defer lock.Unlock() name = applyNamespace(name) descriptions[name] = description return nil }
[ "func", "Desc", "(", "name", "string", ",", "description", "string", ")", "error", "{", "lock", ".", "Lock", "(", ")", "\n", "defer", "lock", ".", "Unlock", "(", ")", "\n\n", "name", "=", "applyNamespace", "(", "name", ")", "\n\n", "descriptions", "[", "name", "]", "=", "description", "\n", "return", "nil", "\n", "}" ]
// Desc sets a helpful descriptive text for a grift. // This description will be shown when `grift list` // is run.
[ "Desc", "sets", "a", "helpful", "descriptive", "text", "for", "a", "grift", ".", "This", "description", "will", "be", "shown", "when", "grift", "list", "is", "run", "." ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L116-L124
56
markbates/grift
grift/grift.go
Run
func Run(name string, c *Context) error { name = applyNamespace(name) if griftList[name] == nil { if name == "list" { PrintGrifts(os.Stdout) return nil } return fmt.Errorf("No task named '%s' defined!", name) } if c.Verbose { defer func(start time.Time) { log.Printf("Completed task %s in %s\n", name, time.Now().Sub(start)) }(time.Now()) log.Printf("Starting task %s\n", name) } return griftList[name](c) }
go
func Run(name string, c *Context) error { name = applyNamespace(name) if griftList[name] == nil { if name == "list" { PrintGrifts(os.Stdout) return nil } return fmt.Errorf("No task named '%s' defined!", name) } if c.Verbose { defer func(start time.Time) { log.Printf("Completed task %s in %s\n", name, time.Now().Sub(start)) }(time.Now()) log.Printf("Starting task %s\n", name) } return griftList[name](c) }
[ "func", "Run", "(", "name", "string", ",", "c", "*", "Context", ")", "error", "{", "name", "=", "applyNamespace", "(", "name", ")", "\n\n", "if", "griftList", "[", "name", "]", "==", "nil", "{", "if", "name", "==", "\"", "\"", "{", "PrintGrifts", "(", "os", ".", "Stdout", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "if", "c", ".", "Verbose", "{", "defer", "func", "(", "start", "time", ".", "Time", ")", "{", "log", ".", "Printf", "(", "\"", "\\n", "\"", ",", "name", ",", "time", ".", "Now", "(", ")", ".", "Sub", "(", "start", ")", ")", "\n", "}", "(", "time", ".", "Now", "(", ")", ")", "\n", "log", ".", "Printf", "(", "\"", "\\n", "\"", ",", "name", ")", "\n", "}", "\n", "return", "griftList", "[", "name", "]", "(", "c", ")", "\n", "}" ]
// Run a grift. This allows for the chaining for grifts. // One grift can Run another grift and so on.
[ "Run", "a", "grift", ".", "This", "allows", "for", "the", "chaining", "for", "grifts", ".", "One", "grift", "can", "Run", "another", "grift", "and", "so", "on", "." ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L128-L145
57
markbates/grift
grift/grift.go
List
func List() []string { keys := []string{} for k := range griftList { keys = append(keys, k) } sort.Strings(keys) return keys }
go
func List() []string { keys := []string{} for k := range griftList { keys = append(keys, k) } sort.Strings(keys) return keys }
[ "func", "List", "(", ")", "[", "]", "string", "{", "keys", ":=", "[", "]", "string", "{", "}", "\n", "for", "k", ":=", "range", "griftList", "{", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "keys", ")", "\n", "return", "keys", "\n", "}" ]
// List of the names of the defined grifts.
[ "List", "of", "the", "names", "of", "the", "defined", "grifts", "." ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L148-L155
58
markbates/grift
grift/grift.go
Exec
func Exec(args []string, verbose bool) error { name := "list" if len(args) >= 1 { name = args[0] } switch name { case "list": PrintGrifts(os.Stdout) default: c := NewContext(name) c.Verbose = verbose if len(args) >= 1 { c.Args = args[1:] } return Run(name, c) } return nil }
go
func Exec(args []string, verbose bool) error { name := "list" if len(args) >= 1 { name = args[0] } switch name { case "list": PrintGrifts(os.Stdout) default: c := NewContext(name) c.Verbose = verbose if len(args) >= 1 { c.Args = args[1:] } return Run(name, c) } return nil }
[ "func", "Exec", "(", "args", "[", "]", "string", ",", "verbose", "bool", ")", "error", "{", "name", ":=", "\"", "\"", "\n", "if", "len", "(", "args", ")", ">=", "1", "{", "name", "=", "args", "[", "0", "]", "\n", "}", "\n", "switch", "name", "{", "case", "\"", "\"", ":", "PrintGrifts", "(", "os", ".", "Stdout", ")", "\n", "default", ":", "c", ":=", "NewContext", "(", "name", ")", "\n", "c", ".", "Verbose", "=", "verbose", "\n", "if", "len", "(", "args", ")", ">=", "1", "{", "c", ".", "Args", "=", "args", "[", "1", ":", "]", "\n", "}", "\n", "return", "Run", "(", "name", ",", "c", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]
// Exec the grift stack. This is the main "entry point" to // the grift system.
[ "Exec", "the", "grift", "stack", ".", "This", "is", "the", "main", "entry", "point", "to", "the", "grift", "system", "." ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L159-L176
59
markbates/grift
grift/grift.go
PrintGrifts
func PrintGrifts(w io.Writer) { fmt.Fprint(w, "Available grifts\n================\n") cnLen := len(CommandName) maxLen := cnLen l := List() for _, k := range l { if (len(k) + cnLen) > maxLen { maxLen = len(k) + cnLen } } for _, k := range l { m := strings.Join([]string{CommandName, k}, " ") suffix := strings.Repeat(" ", (maxLen+3)-len(m)) + " #" fmt.Fprintln(w, strings.Join([]string{m, suffix, descriptions[k]}, " ")) } }
go
func PrintGrifts(w io.Writer) { fmt.Fprint(w, "Available grifts\n================\n") cnLen := len(CommandName) maxLen := cnLen l := List() for _, k := range l { if (len(k) + cnLen) > maxLen { maxLen = len(k) + cnLen } } for _, k := range l { m := strings.Join([]string{CommandName, k}, " ") suffix := strings.Repeat(" ", (maxLen+3)-len(m)) + " #" fmt.Fprintln(w, strings.Join([]string{m, suffix, descriptions[k]}, " ")) } }
[ "func", "PrintGrifts", "(", "w", "io", ".", "Writer", ")", "{", "fmt", ".", "Fprint", "(", "w", ",", "\"", "\\n", "\\n", "\"", ")", "\n\n", "cnLen", ":=", "len", "(", "CommandName", ")", "\n", "maxLen", ":=", "cnLen", "\n", "l", ":=", "List", "(", ")", "\n\n", "for", "_", ",", "k", ":=", "range", "l", "{", "if", "(", "len", "(", "k", ")", "+", "cnLen", ")", ">", "maxLen", "{", "maxLen", "=", "len", "(", "k", ")", "+", "cnLen", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "k", ":=", "range", "l", "{", "m", ":=", "strings", ".", "Join", "(", "[", "]", "string", "{", "CommandName", ",", "k", "}", ",", "\"", "\"", ")", "\n", "suffix", ":=", "strings", ".", "Repeat", "(", "\"", "\"", ",", "(", "maxLen", "+", "3", ")", "-", "len", "(", "m", ")", ")", "+", "\"", "\"", "\n\n", "fmt", ".", "Fprintln", "(", "w", ",", "strings", ".", "Join", "(", "[", "]", "string", "{", "m", ",", "suffix", ",", "descriptions", "[", "k", "]", "}", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "}" ]
// PrintGrifts to the screen, nice, sorted, and with descriptions, // should they exist.
[ "PrintGrifts", "to", "the", "screen", "nice", "sorted", "and", "with", "descriptions", "should", "they", "exist", "." ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L180-L199
60
markbates/grift
grift/context.go
Value
func (c *Context) Value(key interface{}) interface{} { if s, ok := key.(string); ok { if v, ok := c.data[s]; ok { return v } } return c.Context.Value(key) }
go
func (c *Context) Value(key interface{}) interface{} { if s, ok := key.(string); ok { if v, ok := c.data[s]; ok { return v } } return c.Context.Value(key) }
[ "func", "(", "c", "*", "Context", ")", "Value", "(", "key", "interface", "{", "}", ")", "interface", "{", "}", "{", "if", "s", ",", "ok", ":=", "key", ".", "(", "string", ")", ";", "ok", "{", "if", "v", ",", "ok", ":=", "c", ".", "data", "[", "s", "]", ";", "ok", "{", "return", "v", "\n", "}", "\n", "}", "\n", "return", "c", ".", "Context", ".", "Value", "(", "key", ")", "\n", "}" ]
// Value returns a value from the context for the given key
[ "Value", "returns", "a", "value", "from", "the", "context", "for", "the", "given", "key" ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/context.go#L19-L26
61
markbates/grift
grift/context.go
Set
func (c *Context) Set(key string, val interface{}) { c.moot.Lock() defer c.moot.Unlock() c.data[key] = val }
go
func (c *Context) Set(key string, val interface{}) { c.moot.Lock() defer c.moot.Unlock() c.data[key] = val }
[ "func", "(", "c", "*", "Context", ")", "Set", "(", "key", "string", ",", "val", "interface", "{", "}", ")", "{", "c", ".", "moot", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "moot", ".", "Unlock", "(", ")", "\n", "c", ".", "data", "[", "key", "]", "=", "val", "\n", "}" ]
// Set a piece of data onto the Context.
[ "Set", "a", "piece", "of", "data", "onto", "the", "Context", "." ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/context.go#L29-L33
62
markbates/grift
grift/context.go
NewContextWithContext
func NewContextWithContext(name string, ctx context.Context) *Context { return &Context{ Context: ctx, Name: name, Args: []string{}, data: map[interface{}]interface{}{}, moot: &sync.Mutex{}, } }
go
func NewContextWithContext(name string, ctx context.Context) *Context { return &Context{ Context: ctx, Name: name, Args: []string{}, data: map[interface{}]interface{}{}, moot: &sync.Mutex{}, } }
[ "func", "NewContextWithContext", "(", "name", "string", ",", "ctx", "context", ".", "Context", ")", "*", "Context", "{", "return", "&", "Context", "{", "Context", ":", "ctx", ",", "Name", ":", "name", ",", "Args", ":", "[", "]", "string", "{", "}", ",", "data", ":", "map", "[", "interface", "{", "}", "]", "interface", "{", "}", "{", "}", ",", "moot", ":", "&", "sync", ".", "Mutex", "{", "}", ",", "}", "\n", "}" ]
// NewContextWithContext builds and returns a new default Context given an existing context
[ "NewContextWithContext", "builds", "and", "returns", "a", "new", "default", "Context", "given", "an", "existing", "context" ]
ce869fe62d84875913170d186f91a34667e4c732
https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/context.go#L41-L49
63
aymerick/douceur
parser/parser.go
ParseStylesheet
func (parser *Parser) ParseStylesheet() (*css.Stylesheet, error) { result := css.NewStylesheet() // Parse BOM if _, err := parser.parseBOM(); err != nil { return result, err } // Parse list of rules rules, err := parser.ParseRules() if err != nil { return result, err } result.Rules = rules return result, nil }
go
func (parser *Parser) ParseStylesheet() (*css.Stylesheet, error) { result := css.NewStylesheet() // Parse BOM if _, err := parser.parseBOM(); err != nil { return result, err } // Parse list of rules rules, err := parser.ParseRules() if err != nil { return result, err } result.Rules = rules return result, nil }
[ "func", "(", "parser", "*", "Parser", ")", "ParseStylesheet", "(", ")", "(", "*", "css", ".", "Stylesheet", ",", "error", ")", "{", "result", ":=", "css", ".", "NewStylesheet", "(", ")", "\n\n", "// Parse BOM", "if", "_", ",", "err", ":=", "parser", ".", "parseBOM", "(", ")", ";", "err", "!=", "nil", "{", "return", "result", ",", "err", "\n", "}", "\n\n", "// Parse list of rules", "rules", ",", "err", ":=", "parser", ".", "ParseRules", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "err", "\n", "}", "\n\n", "result", ".", "Rules", "=", "rules", "\n\n", "return", "result", ",", "nil", "\n", "}" ]
// ParseStylesheet parses a stylesheet
[ "ParseStylesheet", "parses", "a", "stylesheet" ]
f9e29746e1161076eae141dd235f5d98b546ec3e
https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L55-L72
64
aymerick/douceur
parser/parser.go
ParseRules
func (parser *Parser) ParseRules() ([]*css.Rule, error) { result := []*css.Rule{} inBlock := false if parser.tokenChar("{") { // parsing a block of rules inBlock = true parser.embedLevel++ parser.shiftToken() } for parser.tokenParsable() { if parser.tokenIgnorable() { parser.shiftToken() } else if parser.tokenChar("}") { if !inBlock { errMsg := fmt.Sprintf("Unexpected } character: %s", parser.nextToken().String()) return result, errors.New(errMsg) } parser.shiftToken() parser.embedLevel-- // finished break } else { rule, err := parser.ParseRule() if err != nil { return result, err } rule.EmbedLevel = parser.embedLevel result = append(result, rule) } } return result, parser.err() }
go
func (parser *Parser) ParseRules() ([]*css.Rule, error) { result := []*css.Rule{} inBlock := false if parser.tokenChar("{") { // parsing a block of rules inBlock = true parser.embedLevel++ parser.shiftToken() } for parser.tokenParsable() { if parser.tokenIgnorable() { parser.shiftToken() } else if parser.tokenChar("}") { if !inBlock { errMsg := fmt.Sprintf("Unexpected } character: %s", parser.nextToken().String()) return result, errors.New(errMsg) } parser.shiftToken() parser.embedLevel-- // finished break } else { rule, err := parser.ParseRule() if err != nil { return result, err } rule.EmbedLevel = parser.embedLevel result = append(result, rule) } } return result, parser.err() }
[ "func", "(", "parser", "*", "Parser", ")", "ParseRules", "(", ")", "(", "[", "]", "*", "css", ".", "Rule", ",", "error", ")", "{", "result", ":=", "[", "]", "*", "css", ".", "Rule", "{", "}", "\n\n", "inBlock", ":=", "false", "\n", "if", "parser", ".", "tokenChar", "(", "\"", "\"", ")", "{", "// parsing a block of rules", "inBlock", "=", "true", "\n", "parser", ".", "embedLevel", "++", "\n\n", "parser", ".", "shiftToken", "(", ")", "\n", "}", "\n\n", "for", "parser", ".", "tokenParsable", "(", ")", "{", "if", "parser", ".", "tokenIgnorable", "(", ")", "{", "parser", ".", "shiftToken", "(", ")", "\n", "}", "else", "if", "parser", ".", "tokenChar", "(", "\"", "\"", ")", "{", "if", "!", "inBlock", "{", "errMsg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "parser", ".", "nextToken", "(", ")", ".", "String", "(", ")", ")", "\n", "return", "result", ",", "errors", ".", "New", "(", "errMsg", ")", "\n", "}", "\n\n", "parser", ".", "shiftToken", "(", ")", "\n", "parser", ".", "embedLevel", "--", "\n\n", "// finished", "break", "\n", "}", "else", "{", "rule", ",", "err", ":=", "parser", ".", "ParseRule", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "err", "\n", "}", "\n\n", "rule", ".", "EmbedLevel", "=", "parser", ".", "embedLevel", "\n", "result", "=", "append", "(", "result", ",", "rule", ")", "\n", "}", "\n", "}", "\n\n", "return", "result", ",", "parser", ".", "err", "(", ")", "\n", "}" ]
// ParseRules parses a list of rules
[ "ParseRules", "parses", "a", "list", "of", "rules" ]
f9e29746e1161076eae141dd235f5d98b546ec3e
https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L75-L113
65
aymerick/douceur
parser/parser.go
ParseRule
func (parser *Parser) ParseRule() (*css.Rule, error) { if parser.tokenAtKeyword() { return parser.parseAtRule() } return parser.parseQualifiedRule() }
go
func (parser *Parser) ParseRule() (*css.Rule, error) { if parser.tokenAtKeyword() { return parser.parseAtRule() } return parser.parseQualifiedRule() }
[ "func", "(", "parser", "*", "Parser", ")", "ParseRule", "(", ")", "(", "*", "css", ".", "Rule", ",", "error", ")", "{", "if", "parser", ".", "tokenAtKeyword", "(", ")", "{", "return", "parser", ".", "parseAtRule", "(", ")", "\n", "}", "\n\n", "return", "parser", ".", "parseQualifiedRule", "(", ")", "\n", "}" ]
// ParseRule parses a rule
[ "ParseRule", "parses", "a", "rule" ]
f9e29746e1161076eae141dd235f5d98b546ec3e
https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L116-L122
66
aymerick/douceur
parser/parser.go
ParseDeclarations
func (parser *Parser) ParseDeclarations() ([]*css.Declaration, error) { result := []*css.Declaration{} if parser.tokenChar("{") { parser.shiftToken() } for parser.tokenParsable() { if parser.tokenIgnorable() { parser.shiftToken() } else if parser.tokenChar("}") { // end of block parser.shiftToken() break } else { declaration, err := parser.ParseDeclaration() if err != nil { return result, err } result = append(result, declaration) } } return result, parser.err() }
go
func (parser *Parser) ParseDeclarations() ([]*css.Declaration, error) { result := []*css.Declaration{} if parser.tokenChar("{") { parser.shiftToken() } for parser.tokenParsable() { if parser.tokenIgnorable() { parser.shiftToken() } else if parser.tokenChar("}") { // end of block parser.shiftToken() break } else { declaration, err := parser.ParseDeclaration() if err != nil { return result, err } result = append(result, declaration) } } return result, parser.err() }
[ "func", "(", "parser", "*", "Parser", ")", "ParseDeclarations", "(", ")", "(", "[", "]", "*", "css", ".", "Declaration", ",", "error", ")", "{", "result", ":=", "[", "]", "*", "css", ".", "Declaration", "{", "}", "\n\n", "if", "parser", ".", "tokenChar", "(", "\"", "\"", ")", "{", "parser", ".", "shiftToken", "(", ")", "\n", "}", "\n\n", "for", "parser", ".", "tokenParsable", "(", ")", "{", "if", "parser", ".", "tokenIgnorable", "(", ")", "{", "parser", ".", "shiftToken", "(", ")", "\n", "}", "else", "if", "parser", ".", "tokenChar", "(", "\"", "\"", ")", "{", "// end of block", "parser", ".", "shiftToken", "(", ")", "\n", "break", "\n", "}", "else", "{", "declaration", ",", "err", ":=", "parser", ".", "ParseDeclaration", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "err", "\n", "}", "\n\n", "result", "=", "append", "(", "result", ",", "declaration", ")", "\n", "}", "\n", "}", "\n\n", "return", "result", ",", "parser", ".", "err", "(", ")", "\n", "}" ]
// ParseDeclarations parses a list of declarations
[ "ParseDeclarations", "parses", "a", "list", "of", "declarations" ]
f9e29746e1161076eae141dd235f5d98b546ec3e
https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L125-L150
67
aymerick/douceur
parser/parser.go
ParseDeclaration
func (parser *Parser) ParseDeclaration() (*css.Declaration, error) { result := css.NewDeclaration() curValue := "" for parser.tokenParsable() { if parser.tokenChar(":") { result.Property = strings.TrimSpace(curValue) curValue = "" parser.shiftToken() } else if parser.tokenChar(";") || parser.tokenChar("}") { if result.Property == "" { errMsg := fmt.Sprintf("Unexpected ; character: %s", parser.nextToken().String()) return result, errors.New(errMsg) } if importantRegexp.MatchString(curValue) { result.Important = true curValue = importantRegexp.ReplaceAllString(curValue, "") } result.Value = strings.TrimSpace(curValue) if parser.tokenChar(";") { parser.shiftToken() } // finished break } else { token := parser.shiftToken() curValue += token.Value } } // log.Printf("[parsed] Declaration: %s", result.String()) return result, parser.err() }
go
func (parser *Parser) ParseDeclaration() (*css.Declaration, error) { result := css.NewDeclaration() curValue := "" for parser.tokenParsable() { if parser.tokenChar(":") { result.Property = strings.TrimSpace(curValue) curValue = "" parser.shiftToken() } else if parser.tokenChar(";") || parser.tokenChar("}") { if result.Property == "" { errMsg := fmt.Sprintf("Unexpected ; character: %s", parser.nextToken().String()) return result, errors.New(errMsg) } if importantRegexp.MatchString(curValue) { result.Important = true curValue = importantRegexp.ReplaceAllString(curValue, "") } result.Value = strings.TrimSpace(curValue) if parser.tokenChar(";") { parser.shiftToken() } // finished break } else { token := parser.shiftToken() curValue += token.Value } } // log.Printf("[parsed] Declaration: %s", result.String()) return result, parser.err() }
[ "func", "(", "parser", "*", "Parser", ")", "ParseDeclaration", "(", ")", "(", "*", "css", ".", "Declaration", ",", "error", ")", "{", "result", ":=", "css", ".", "NewDeclaration", "(", ")", "\n", "curValue", ":=", "\"", "\"", "\n\n", "for", "parser", ".", "tokenParsable", "(", ")", "{", "if", "parser", ".", "tokenChar", "(", "\"", "\"", ")", "{", "result", ".", "Property", "=", "strings", ".", "TrimSpace", "(", "curValue", ")", "\n", "curValue", "=", "\"", "\"", "\n\n", "parser", ".", "shiftToken", "(", ")", "\n", "}", "else", "if", "parser", ".", "tokenChar", "(", "\"", "\"", ")", "||", "parser", ".", "tokenChar", "(", "\"", "\"", ")", "{", "if", "result", ".", "Property", "==", "\"", "\"", "{", "errMsg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "parser", ".", "nextToken", "(", ")", ".", "String", "(", ")", ")", "\n", "return", "result", ",", "errors", ".", "New", "(", "errMsg", ")", "\n", "}", "\n\n", "if", "importantRegexp", ".", "MatchString", "(", "curValue", ")", "{", "result", ".", "Important", "=", "true", "\n", "curValue", "=", "importantRegexp", ".", "ReplaceAllString", "(", "curValue", ",", "\"", "\"", ")", "\n", "}", "\n\n", "result", ".", "Value", "=", "strings", ".", "TrimSpace", "(", "curValue", ")", "\n\n", "if", "parser", ".", "tokenChar", "(", "\"", "\"", ")", "{", "parser", ".", "shiftToken", "(", ")", "\n", "}", "\n\n", "// finished", "break", "\n", "}", "else", "{", "token", ":=", "parser", ".", "shiftToken", "(", ")", "\n", "curValue", "+=", "token", ".", "Value", "\n", "}", "\n", "}", "\n\n", "// log.Printf(\"[parsed] Declaration: %s\", result.String())", "return", "result", ",", "parser", ".", "err", "(", ")", "\n", "}" ]
// ParseDeclaration parses a declaration
[ "ParseDeclaration", "parses", "a", "declaration" ]
f9e29746e1161076eae141dd235f5d98b546ec3e
https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L153-L191
68
aymerick/douceur
parser/parser.go
parseAtRule
func (parser *Parser) parseAtRule() (*css.Rule, error) { // parse rule name (eg: "@import") token := parser.shiftToken() result := css.NewRule(css.AtRule) result.Name = token.Value for parser.tokenParsable() { if parser.tokenChar(";") { parser.shiftToken() // finished break } else if parser.tokenChar("{") { if result.EmbedsRules() { // parse rules block rules, err := parser.ParseRules() if err != nil { return result, err } result.Rules = rules } else { // parse declarations block declarations, err := parser.ParseDeclarations() if err != nil { return result, err } result.Declarations = declarations } // finished break } else { // parse prelude prelude, err := parser.parsePrelude() if err != nil { return result, err } result.Prelude = prelude } } // log.Printf("[parsed] Rule: %s", result.String()) return result, parser.err() }
go
func (parser *Parser) parseAtRule() (*css.Rule, error) { // parse rule name (eg: "@import") token := parser.shiftToken() result := css.NewRule(css.AtRule) result.Name = token.Value for parser.tokenParsable() { if parser.tokenChar(";") { parser.shiftToken() // finished break } else if parser.tokenChar("{") { if result.EmbedsRules() { // parse rules block rules, err := parser.ParseRules() if err != nil { return result, err } result.Rules = rules } else { // parse declarations block declarations, err := parser.ParseDeclarations() if err != nil { return result, err } result.Declarations = declarations } // finished break } else { // parse prelude prelude, err := parser.parsePrelude() if err != nil { return result, err } result.Prelude = prelude } } // log.Printf("[parsed] Rule: %s", result.String()) return result, parser.err() }
[ "func", "(", "parser", "*", "Parser", ")", "parseAtRule", "(", ")", "(", "*", "css", ".", "Rule", ",", "error", ")", "{", "// parse rule name (eg: \"@import\")", "token", ":=", "parser", ".", "shiftToken", "(", ")", "\n\n", "result", ":=", "css", ".", "NewRule", "(", "css", ".", "AtRule", ")", "\n", "result", ".", "Name", "=", "token", ".", "Value", "\n\n", "for", "parser", ".", "tokenParsable", "(", ")", "{", "if", "parser", ".", "tokenChar", "(", "\"", "\"", ")", "{", "parser", ".", "shiftToken", "(", ")", "\n\n", "// finished", "break", "\n", "}", "else", "if", "parser", ".", "tokenChar", "(", "\"", "\"", ")", "{", "if", "result", ".", "EmbedsRules", "(", ")", "{", "// parse rules block", "rules", ",", "err", ":=", "parser", ".", "ParseRules", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "err", "\n", "}", "\n\n", "result", ".", "Rules", "=", "rules", "\n", "}", "else", "{", "// parse declarations block", "declarations", ",", "err", ":=", "parser", ".", "ParseDeclarations", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "err", "\n", "}", "\n\n", "result", ".", "Declarations", "=", "declarations", "\n", "}", "\n\n", "// finished", "break", "\n", "}", "else", "{", "// parse prelude", "prelude", ",", "err", ":=", "parser", ".", "parsePrelude", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "err", "\n", "}", "\n\n", "result", ".", "Prelude", "=", "prelude", "\n", "}", "\n", "}", "\n\n", "// log.Printf(\"[parsed] Rule: %s\", result.String())", "return", "result", ",", "parser", ".", "err", "(", ")", "\n", "}" ]
// Parse an At Rule
[ "Parse", "an", "At", "Rule" ]
f9e29746e1161076eae141dd235f5d98b546ec3e
https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L194-L242

Dataset Card for "codexglue_code2text_go"

More Information needed

Downloads last month
56