_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q180100 | getV3Filter | test | func getV3Filter(code []byte) (v3Filter, error) {
// check if filter is a known standard filter
c := crc32.ChecksumIEEE(code)
for _, f := range standardV3Filters {
if f.crc == c && f.len == len(code) {
return f.f, nil
}
}
// create new vm filter
f := new(vmFilter)
r := newRarBitReader(bytes.NewReader(cod... | go | {
"resource": ""
} |
q180101 | init | test | func (d *decoder29) init(r io.ByteReader, reset bool) error {
if d.br == nil {
d.br = newRarBitReader(r)
} else {
d.br.reset(r)
}
d.eof = false
if reset {
d.initFilters()
d.lz.reset()
d.ppm.reset()
d.decode = nil
}
if d.decode == nil {
return d.readBlockHeader()
}
return nil
} | go | {
"resource": ""
} |
q180102 | readBlockHeader | test | func (d *decoder29) readBlockHeader() error {
d.br.alignByte()
n, err := d.br.readBits(1)
if err == nil {
if n > 0 {
d.decode = d.ppm.decode
err = d.ppm.init(d.br)
} else {
d.decode = d.lz.decode
err = d.lz.init(d.br)
}
}
if err == io.EOF {
err = errDecoderOutOfData
}
return err
} | go | {
"resource": ""
} |
q180103 | readCodeLengthTable | test | func readCodeLengthTable(br bitReader, codeLength []byte, addOld bool) error {
var bitlength [20]byte
for i := 0; i < len(bitlength); i++ {
n, err := br.readBits(4)
if err != nil {
return err
}
if n == 0xf {
cnt, err := br.readBits(4)
if err != nil {
return err
}
if cnt > 0 {
// array a... | go | {
"resource": ""
} |
q180104 | shrinkStates | test | func (c *context) shrinkStates(states []state, size int) []state {
i1 := units2Index[(len(states)+1)>>1]
i2 := units2Index[(size+1)>>1]
if size == 1 {
// store state in context, and free states block
n := c.statesIndex()
c.s[1] = states[0]
states = c.s[1:]
c.a.addFreeBlock(n, i1)
} else if i1 != i2 {
i... | go | {
"resource": ""
} |
q180105 | expandStates | test | func (c *context) expandStates() []state {
states := c.states()
ns := len(states)
if ns == 1 {
s := states[0]
n := c.a.allocUnits(1)
if n == 0 {
return nil
}
c.setStatesIndex(n)
states = c.a.states[n:]
states[0] = s
} else if ns&0x1 == 0 {
u := ns >> 1
i1 := units2Index[u]
i2 := units2Index[u... | go | {
"resource": ""
} |
q180106 | pushByte | test | func (a *subAllocator) pushByte(c byte) int32 {
si := a.heap1Lo / 6 // state index
oi := a.heap1Lo % 6 // byte position in state
switch oi {
case 0:
a.states[si].sym = c
case 1:
a.states[si].freq = c
default:
n := (uint(oi) - 2) * 8
mask := ^(uint32(0xFF) << n)
succ := uint32(a.states[si].succ) & mask
... | go | {
"resource": ""
} |
q180107 | succByte | test | func (a *subAllocator) succByte(i int32) byte {
i = -i
si := i / 6
oi := i % 6
switch oi {
case 0:
return a.states[si].sym
case 1:
return a.states[si].freq
default:
n := (uint(oi) - 2) * 8
succ := uint32(a.states[si].succ) >> n
return byte(succ & 0xff)
}
} | go | {
"resource": ""
} |
q180108 | succContext | test | func (a *subAllocator) succContext(i int32) *context {
if i <= 0 {
return nil
}
return &context{i: i, s: a.states[i : i+2 : i+2], a: a}
} | go | {
"resource": ""
} |
q180109 | calcAes30Params | test | func calcAes30Params(pass []uint16, salt []byte) (key, iv []byte) {
p := make([]byte, 0, len(pass)*2+len(salt))
for _, v := range pass {
p = append(p, byte(v), byte(v>>8))
}
p = append(p, salt...)
hash := sha1.New()
iv = make([]byte, 16)
s := make([]byte, 0, hash.Size())
for i := 0; i < hashRounds; i++ {
h... | go | {
"resource": ""
} |
q180110 | parseDosTime | test | func parseDosTime(t uint32) time.Time {
n := int(t)
sec := n & 0x1f << 1
min := n >> 5 & 0x3f
hr := n >> 11 & 0x1f
day := n >> 16 & 0x1f
mon := time.Month(n >> 21 & 0x0f)
yr := n>>25&0x7f + 1980
return time.Date(yr, mon, day, hr, min, sec, 0, time.Local)
} | go | {
"resource": ""
} |
q180111 | decodeName | test | func decodeName(buf []byte) string {
i := bytes.IndexByte(buf, 0)
if i < 0 {
return string(buf) // filename is UTF-8
}
name := buf[:i]
encName := readBuf(buf[i+1:])
if len(encName) < 2 {
return "" // invalid encoding
}
highByte := uint16(encName.byte()) << 8
flags := encName.byte()
flagBits := 8
var wch... | go | {
"resource": ""
} |
q180112 | readExtTimes | test | func readExtTimes(f *fileBlockHeader, b *readBuf) {
if len(*b) < 2 {
return // invalid, not enough data
}
flags := b.uint16()
ts := []*time.Time{&f.ModificationTime, &f.CreationTime, &f.AccessTime}
for i, t := range ts {
n := flags >> uint((3-i)*4)
if n&0x8 == 0 {
continue
}
if i != 0 { // Modificat... | go | {
"resource": ""
} |
q180113 | readBlockHeader | test | func (a *archive15) readBlockHeader() (*blockHeader15, error) {
var err error
b := a.buf[:7]
r := io.Reader(a.v)
if a.encrypted {
salt := a.buf[:saltSize]
_, err = io.ReadFull(r, salt)
if err != nil {
return nil, err
}
key, iv := a.getKeys(salt)
r = newAesDecryptReader(r, key, iv)
err = readFull(r,... | go | {
"resource": ""
} |
q180114 | newArchive15 | test | func newArchive15(r *bufio.Reader, password string) fileBlockReader {
a := new(archive15)
a.v = r
a.pass = utf16.Encode([]rune(password)) // convert to UTF-16
a.checksum.Hash32 = crc32.NewIEEE()
a.buf = readBuf(make([]byte, 100))
return a
} | go | {
"resource": ""
} |
q180115 | readFilter5Data | test | func readFilter5Data(br bitReader) (int, error) {
// TODO: should data really be uint? (for 32bit ints).
// It will be masked later anyway by decode window mask.
bytes, err := br.readBits(2)
if err != nil {
return 0, err
}
bytes++
var data int
for i := 0; i < bytes; i++ {
n, err := br.readBits(8)
if err ... | go | {
"resource": ""
} |
q180116 | writeByte | test | func (w *window) writeByte(c byte) {
w.buf[w.w] = c
w.w = (w.w + 1) & w.mask
} | go | {
"resource": ""
} |
q180117 | copyBytes | test | func (w *window) copyBytes(len, off int) {
len &= w.mask
n := w.available()
if len > n {
// if there is not enough space availaible we copy
// as much as we can and save the offset and length
// of the remaining data to be copied later.
w.l = len - n
w.o = off
len = n
}
i := (w.w - off) & w.mask
for... | go | {
"resource": ""
} |
q180118 | read | test | func (w *window) read(p []byte) (n int) {
if w.r > w.w {
n = copy(p, w.buf[w.r:])
w.r = (w.r + n) & w.mask
p = p[n:]
}
if w.r < w.w {
l := copy(p, w.buf[w.r:w.w])
w.r += l
n += l
}
if w.l > 0 && n > 0 {
// if we have successfully read data, copy any
// leftover data from a previous copyBytes.
l :... | go | {
"resource": ""
} |
q180119 | queueFilter | test | func (d *decodeReader) queueFilter(f *filterBlock) error {
if f.reset {
d.filters = nil
}
if len(d.filters) >= maxQueuedFilters {
return errTooManyFilters
}
// offset & length must be < window size
f.offset &= d.win.mask
f.length &= d.win.mask
// make offset relative to previous filter in list
for _, fb :=... | go | {
"resource": ""
} |
q180120 | processFilters | test | func (d *decodeReader) processFilters() (err error) {
f := d.filters[0]
if f.offset > 0 {
return nil
}
d.filters = d.filters[1:]
if d.win.buffered() < f.length {
// fill() didn't return enough bytes
err = d.readErr()
if err == nil || err == io.EOF {
return errInvalidFilter
}
return err
}
if cap(d... | go | {
"resource": ""
} |
q180121 | fill | test | func (d *decodeReader) fill() {
if d.err != nil {
return
}
var fl []*filterBlock
fl, d.err = d.dec.fill(&d.win) // fill window using decoder
for _, f := range fl {
err := d.queueFilter(f)
if err != nil {
d.err = err
return
}
}
} | go | {
"resource": ""
} |
q180122 | Read | test | func (d *decodeReader) Read(p []byte) (n int, err error) {
if len(d.outbuf) == 0 {
// no filter output, see if we need to create more
if d.win.buffered() == 0 {
// fill empty window
d.fill()
if d.win.buffered() == 0 {
return 0, d.readErr()
}
} else if len(d.filters) > 0 {
f := d.filters[0]
... | go | {
"resource": ""
} |
q180123 | readFull | test | func readFull(r io.Reader, buf []byte) error {
_, err := io.ReadFull(r, buf)
if err == io.EOF {
return io.ErrUnexpectedEOF
}
return err
} | go | {
"resource": ""
} |
q180124 | findSig | test | func findSig(br *bufio.Reader) (int, error) {
for n := 0; n <= maxSfxSize; {
b, err := br.ReadSlice(sigPrefix[0])
n += len(b)
if err == bufio.ErrBufferFull {
continue
} else if err != nil {
if err == io.EOF {
err = errNoSig
}
return 0, err
}
b, err = br.Peek(len(sigPrefix[1:]) + 2)
if er... | go | {
"resource": ""
} |
q180125 | execute | test | func (v *vm) execute(cmd []command) {
v.ip = 0 // reset instruction pointer
for n := 0; n < maxCommands; n++ {
ip := v.ip
if ip >= uint32(len(cmd)) {
return
}
ins := cmd[ip]
ins.f(v, ins.bm, ins.op) // run cpu instruction
if v.ipMod {
// command modified ip, don't increment
v.ipMod = false
} el... | go | {
"resource": ""
} |
q180126 | newVM | test | func newVM(mem []byte) *vm {
v := new(vm)
if cap(mem) < vmSize+4 {
v.m = make([]byte, vmSize+4)
copy(v.m, mem)
} else {
v.m = mem[:vmSize+4]
for i := len(mem); i < len(v.m); i++ {
v.m[i] = 0
}
}
v.r[7] = vmSize
return v
} | go | {
"resource": ""
} |
q180127 | limitBitReader | test | func limitBitReader(br bitReader, n int, err error) bitReader {
return &limitedBitReader{br, n, err}
} | go | {
"resource": ""
} |
q180128 | readUint32 | test | func (r *rarBitReader) readUint32() (uint32, error) {
n, err := r.readBits(2)
if err != nil {
return 0, err
}
if n != 1 {
n, err = r.readBits(4 << uint(n))
return uint32(n), err
}
n, err = r.readBits(4)
if err != nil {
return 0, err
}
if n == 0 {
n, err = r.readBits(8)
n |= -1 << 8
return uint32(... | go | {
"resource": ""
} |
q180129 | step3 | test | func step3(word *snowballword.SnowballWord) bool {
// Search for a DERIVATIONAL ending in R2 (i.e. the entire
// ending must lie in R2), and if one is found, remove it.
suffix, _ := word.RemoveFirstSuffixIn(word.R2start, "ост", "ость")
if suffix != "" {
return true
}
return false
} | go | {
"resource": ""
} |
q180130 | Stem | test | func Stem(word string, stemStopwWords bool) string {
word = strings.ToLower(strings.TrimSpace(word))
// Return small words and stop words
if len(word) <= 2 || (stemStopwWords == false && isStopWord(word)) {
return word
}
// Return special words immediately
if specialVersion := stemSpecialWord(word); specialV... | go | {
"resource": ""
} |
q180131 | step6 | test | func step6(word *snowballword.SnowballWord) bool {
// If the words ends é or è (unicode code points 233 and 232)
// followed by at least one non-vowel, remove the accent from the e.
// Note, this step is oddly articulated on Porter's Snowball website:
// http://snowball.tartarus.org/algorithms/french/stemmer.html... | go | {
"resource": ""
} |
q180132 | step5 | test | func step5(word *snowballword.SnowballWord) bool {
suffix, _ := word.FirstSuffix("enn", "onn", "ett", "ell", "eill")
if suffix != "" {
word.RemoveLastNRunes(1)
}
return false
} | go | {
"resource": ""
} |
q180133 | step2a | test | func step2a(word *snowballword.SnowballWord) bool {
suffix, suffixRunes := word.FirstSuffixIn(word.RVstart, len(word.RS), "ya", "ye", "yan", "yen", "yeron", "yendo", "yo", "yó", "yas", "yes", "yais", "yamos")
if suffix != "" {
idx := len(word.RS) - len(suffixRunes) - 1
if idx >= 0 && word.RS[idx] == 117 {
word... | go | {
"resource": ""
} |
q180134 | step4 | test | func step4(word *snowballword.SnowballWord) bool {
// (1) Undouble "н", or, 2) if the word ends with a SUPERLATIVE ending,
// (remove it and undouble н n), or 3) if the word ends ь (') (soft sign)
// remove it.
// Undouble "н"
if word.HasSuffixRunes([]rune("нн")) {
word.RemoveLastNRunes(1)
return true
}
/... | go | {
"resource": ""
} |
q180135 | Stem | test | func Stem(word, language string, stemStopWords bool) (stemmed string, err error) {
var f func(string, bool) string
switch language {
case "english":
f = english.Stem
case "spanish":
f = spanish.Stem
case "french":
f = french.Stem
case "russian":
f = russian.Stem
case "swedish":
f = swedish.Stem
case ... | go | {
"resource": ""
} |
q180136 | step1c | test | func step1c(w *snowballword.SnowballWord) bool {
rsLen := len(w.RS)
// Replace suffix y or Y by i if preceded by a non-vowel which is not
// the first letter of the word (so cry -> cri, by -> by, say -> say)
//
// Note: the unicode code points for
// y, Y, & i are 121, 89, & 105 respectively.
//
if len(w.RS) ... | go | {
"resource": ""
} |
q180137 | step3 | test | func step3(w *snowballword.SnowballWord) bool {
suffix, suffixRunes := w.FirstSuffix(
"ational", "tional", "alize", "icate", "ative",
"iciti", "ical", "ful", "ness",
)
// If it is not in R1, do nothing
if suffix == "" || len(suffixRunes) > len(w.RS)-w.R1start {
return false
}
// Handle special cases wher... | go | {
"resource": ""
} |
q180138 | isStopWord | test | func isStopWord(word string) bool {
switch word {
case "au", "aux", "avec", "ce", "ces", "dans", "de", "des", "du",
"elle", "en", "et", "eux", "il", "je", "la", "le", "leur",
"lui", "ma", "mais", "me", "même", "mes", "moi", "mon", "ne",
"nos", "notre", "nous", "on", "ou", "par", "pas", "pour", "qu",
"que", "q... | go | {
"resource": ""
} |
q180139 | capitalizeYUI | test | func capitalizeYUI(word *snowballword.SnowballWord) {
// Keep track of vowels that we see
vowelPreviously := false
// Peak ahead to see if the next rune is a vowel
vowelNext := func(j int) bool {
return (j+1 < len(word.RS) && isLowerVowel(word.RS[j+1]))
}
// Look at all runes
for i := 0; i < len(word.RS); i... | go | {
"resource": ""
} |
q180140 | step2 | test | func step2(w *snowballword.SnowballWord) bool {
// Possible sufficies for this step, longest first.
suffix, suffixRunes := w.FirstSuffix(
"ational", "fulness", "iveness", "ization", "ousness",
"biliti", "lessli", "tional", "alism", "aliti", "ation",
"entli", "fulli", "iviti", "ousli", "anci", "abli",
"alli",... | go | {
"resource": ""
} |
q180141 | step3 | test | func step3(word *snowballword.SnowballWord) bool {
suffix, suffixRunes := word.FirstSuffixIfIn(word.RVstart, len(word.RS),
"os", "a", "o", "á", "í", "ó", "e", "é",
)
// No suffix found, nothing to do.
//
if suffix == "" {
return false
}
// Remove all these suffixes
word.RemoveLastNRunes(len(suffixRunes))
... | go | {
"resource": ""
} |
q180142 | step0 | test | func step0(w *snowballword.SnowballWord) bool {
suffix, suffixRunes := w.FirstSuffix("'s'", "'s", "'")
if suffix == "" {
return false
}
w.RemoveLastNRunes(len(suffixRunes))
return true
} | go | {
"resource": ""
} |
q180143 | VnvSuffix | test | func VnvSuffix(word *snowballword.SnowballWord, f isVowelFunc, start int) int {
for i := 1; i < len(word.RS[start:]); i++ {
j := start + i
if f(word.RS[j-1]) && !f(word.RS[j]) {
return j + 1
}
}
return len(word.RS)
} | go | {
"resource": ""
} |
q180144 | step1 | test | func step1(w *snowballword.SnowballWord) bool {
// Possible sufficies for this step, longest first.
suffixes := []string{
"heterna", "hetens", "anden", "heten", "heter", "arnas",
"ernas", "ornas", "andes", "arens", "andet", "arna", "erna",
"orna", "ande", "arne", "aste", "aren", "ades", "erns", "ade",
"are",... | go | {
"resource": ""
} |
q180145 | step2a | test | func step2a(word *snowballword.SnowballWord) bool {
// Search for the longest among the following suffixes
// in RV and if found, delete if preceded by a non-vowel.
suffix, suffixRunes := word.FirstSuffixIn(word.RVstart, len(word.RS),
"issantes", "issaIent", "issions", "issants", "issante",
"iraIent", "issons"... | go | {
"resource": ""
} |
q180146 | removePerfectiveGerundEnding | test | func removePerfectiveGerundEnding(word *snowballword.SnowballWord) bool {
suffix, suffixRunes := word.FirstSuffixIn(word.RVstart, len(word.RS),
"ившись", "ывшись", "вшись", "ивши", "ывши", "вши", "ив", "ыв", "в",
)
switch suffix {
case "в", "вши", "вшись":
// These are "Group 1" perfective gerund endings.
//... | go | {
"resource": ""
} |
q180147 | removeAdjectivalEnding | test | func removeAdjectivalEnding(word *snowballword.SnowballWord) bool {
// Remove adjectival endings. Start by looking for
// an adjective ending.
//
suffix, _ := word.RemoveFirstSuffixIn(word.RVstart,
"ими", "ыми", "его", "ого", "ему", "ому", "ее", "ие",
"ые", "ое", "ей", "ий", "ый", "ой", "ем", "им", "ым",
"о... | go | {
"resource": ""
} |
q180148 | step2b | test | func step2b(word *snowballword.SnowballWord) bool {
suffix, suffixRunes := word.FirstSuffixIn(word.RVstart, len(word.RS),
"iésemos", "iéramos", "iríamos", "eríamos", "aríamos", "ásemos",
"áramos", "ábamos", "isteis", "iríais", "iremos", "ieseis",
"ierais", "eríais", "eremos", "asteis", "aríais", "aremos",
"íam... | go | {
"resource": ""
} |
q180149 | step4 | test | func step4(word *snowballword.SnowballWord) bool {
hadChange := false
if word.String() == "voudrion" {
log.Println("...", word)
}
// If the word ends s (unicode code point 115),
// not preceded by a, i, o, u, è or s, delete it.
//
if idx := len(word.RS) - 1; idx >= 1 && word.RS[idx] == 115 {
switch word.R... | go | {
"resource": ""
} |
q180150 | step5 | test | func step5(w *snowballword.SnowballWord) bool {
// Last rune index = `lri`
lri := len(w.RS) - 1
// If R1 is emtpy, R2 is also empty, and we
// need not do anything in step 5.
//
if w.R1start > lri {
return false
}
if w.RS[lri] == 101 {
// The word ends with "e", which is unicode code point 101.
// De... | go | {
"resource": ""
} |
q180151 | Stem | test | func Stem(word string, stemStopwWords bool) string {
word = strings.ToLower(strings.TrimSpace(word))
// Return small words and stop words
if len(word) <= 2 || (stemStopwWords == false && isStopWord(word)) {
return word
}
w := snowballword.New(word)
// Stem the word. Note, each of these
// steps will alter... | go | {
"resource": ""
} |
q180152 | Stem | test | func Stem(word string, stemStopwWords bool) string {
word = strings.ToLower(strings.TrimSpace(word))
w := snowballword.New(word)
// Return small words and stop words
if len(w.RS) <= 2 || (stemStopwWords == false && isStopWord(word)) {
return word
}
preprocess(w)
step1(w)
step2(w)
step3(w)
step4(w)
retur... | go | {
"resource": ""
} |
q180153 | isStopWord | test | func isStopWord(word string) bool {
switch word {
case "ut", "få", "hadde", "hva", "tilbake", "vil", "han", "meget", "men", "vi", "en", "før",
"samme", "stille", "inn", "er", "kan", "makt", "ved", "forsøke", "hvis", "part", "rett",
"måte", "denne", "mer", "i", "lang", "ny", "hans", "hvilken", "tid", "vite", "her"... | go | {
"resource": ""
} |
q180154 | isStopWord | test | func isStopWord(word string) bool {
switch word {
case "och", "det", "att", "i", "en", "jag", "hon", "som", "han",
"på", "den", "med", "var", "sig", "för", "så", "till", "är", "men",
"ett", "om", "hade", "de", "av", "icke", "mig", "du", "henne", "då",
"sin", "nu", "har", "inte", "hans", "honom", "skulle", "henn... | go | {
"resource": ""
} |
q180155 | New | test | func New(in string) (word *SnowballWord) {
word = &SnowballWord{RS: []rune(in)}
word.R1start = len(word.RS)
word.R2start = len(word.RS)
word.RVstart = len(word.RS)
return
} | go | {
"resource": ""
} |
q180156 | RemoveLastNRunes | test | func (w *SnowballWord) RemoveLastNRunes(n int) {
w.RS = w.RS[:len(w.RS)-n]
w.resetR1R2()
} | go | {
"resource": ""
} |
q180157 | resetR1R2 | test | func (w *SnowballWord) resetR1R2() {
rsLen := len(w.RS)
if w.R1start > rsLen {
w.R1start = rsLen
}
if w.R2start > rsLen {
w.R2start = rsLen
}
if w.RVstart > rsLen {
w.RVstart = rsLen
}
} | go | {
"resource": ""
} |
q180158 | slice | test | func (w *SnowballWord) slice(start, stop int) []rune {
startMin := 0
if start < startMin {
start = startMin
}
max := len(w.RS) - 1
if start > max {
start = max
}
if stop > max {
stop = max
}
return w.RS[start:stop]
} | go | {
"resource": ""
} |
q180159 | FitsInR1 | test | func (w *SnowballWord) FitsInR1(x int) bool {
return w.R1start <= len(w.RS)-x
} | go | {
"resource": ""
} |
q180160 | FitsInR2 | test | func (w *SnowballWord) FitsInR2(x int) bool {
return w.R2start <= len(w.RS)-x
} | go | {
"resource": ""
} |
q180161 | FitsInRV | test | func (w *SnowballWord) FitsInRV(x int) bool {
return w.RVstart <= len(w.RS)-x
} | go | {
"resource": ""
} |
q180162 | FirstPrefix | test | func (w *SnowballWord) FirstPrefix(prefixes ...string) (foundPrefix string, foundPrefixRunes []rune) {
found := false
rsLen := len(w.RS)
for _, prefix := range prefixes {
prefixRunes := []rune(prefix)
if len(prefixRunes) > rsLen {
continue
}
found = true
for i, r := range prefixRunes {
if i > rsLen... | go | {
"resource": ""
} |
q180163 | HasSuffixRunes | test | func (w *SnowballWord) HasSuffixRunes(suffixRunes []rune) bool {
return w.HasSuffixRunesIn(0, len(w.RS), suffixRunes)
} | go | {
"resource": ""
} |
q180164 | FirstSuffixIfIn | test | func (w *SnowballWord) FirstSuffixIfIn(startPos, endPos int, suffixes ...string) (suffix string, suffixRunes []rune) {
for _, suffix := range suffixes {
suffixRunes := []rune(suffix)
if w.HasSuffixRunesIn(0, endPos, suffixRunes) {
if endPos-len(suffixRunes) >= startPos {
return suffix, suffixRunes
} else... | go | {
"resource": ""
} |
q180165 | RemoveFirstSuffixIfIn | test | func (w *SnowballWord) RemoveFirstSuffixIfIn(startPos int, suffixes ...string) (suffix string, suffixRunes []rune) {
suffix, suffixRunes = w.FirstSuffixIfIn(startPos, len(w.RS), suffixes...)
if suffix != "" {
w.RemoveLastNRunes(len(suffixRunes))
}
return
} | go | {
"resource": ""
} |
q180166 | RemoveFirstSuffix | test | func (w *SnowballWord) RemoveFirstSuffix(suffixes ...string) (suffix string, suffixRunes []rune) {
return w.RemoveFirstSuffixIn(0, suffixes...)
} | go | {
"resource": ""
} |
q180167 | FirstSuffix | test | func (w *SnowballWord) FirstSuffix(suffixes ...string) (suffix string, suffixRunes []rune) {
return w.FirstSuffixIfIn(0, len(w.RS), suffixes...)
} | go | {
"resource": ""
} |
q180168 | preprocess | test | func preprocess(word *snowballword.SnowballWord) {
// Clean up apostrophes
normalizeApostrophes(word)
trimLeftApostrophes(word)
// Capitalize Y's that are not behaving
// as vowels.
capitalizeYs(word)
// Find the two regions, R1 & R2
r1start, r2start := r1r2(word)
word.R1start = r1start
word.R2start = r2st... | go | {
"resource": ""
} |
q180169 | step0 | test | func step0(word *snowballword.SnowballWord) bool {
// Search for the longest among the following suffixes
suffix1, suffix1Runes := word.FirstSuffixIn(word.RVstart, len(word.RS),
"selas", "selos", "sela", "selo", "las", "les",
"los", "nos", "me", "se", "la", "le", "lo",
)
// If the suffix empty or not in RV, w... | go | {
"resource": ""
} |
q180170 | step1b | test | func step1b(w *snowballword.SnowballWord) bool {
suffix, suffixRunes := w.FirstSuffix("eedly", "ingly", "edly", "ing", "eed", "ed")
switch suffix {
case "":
// No suffix found
return false
case "eed", "eedly":
// Replace by ee if in R1
if len(suffixRunes) <= len(w.RS)-w.R1start {
w.ReplaceSuffixRune... | go | {
"resource": ""
} |
q180171 | step2b | test | func step2b(word *snowballword.SnowballWord) bool {
// Search for the longest among the following suffixes in RV.
//
suffix, suffixRunes := word.FirstSuffixIn(word.RVstart, len(word.RS),
"eraIent", "assions", "erions", "assiez", "assent",
"èrent", "eront", "erons", "eriez", "erait", "erais",
"asses", "antes",... | go | {
"resource": ""
} |
q180172 | capitalizeYs | test | func capitalizeYs(word *snowballword.SnowballWord) (numCapitalizations int) {
for i, r := range word.RS {
// (Note: Y & y unicode code points = 89 & 121)
if r == 121 && (i == 0 || isLowerVowel(word.RS[i-1])) {
word.RS[i] = 89
numCapitalizations += 1
}
}
return
} | go | {
"resource": ""
} |
q180173 | uncapitalizeYs | test | func uncapitalizeYs(word *snowballword.SnowballWord) {
for i, r := range word.RS {
// (Note: Y & y unicode code points = 89 & 121)
if r == 89 {
word.RS[i] = 121
}
}
return
} | go | {
"resource": ""
} |
q180174 | stemSpecialWord | test | func stemSpecialWord(word string) (stemmed string) {
switch word {
case "skis":
stemmed = "ski"
case "skies":
stemmed = "sky"
case "dying":
stemmed = "die"
case "lying":
stemmed = "lie"
case "tying":
stemmed = "tie"
case "idly":
stemmed = "idl"
case "gently":
stemmed = "gentl"
case "ugly":
stem... | go | {
"resource": ""
} |
q180175 | isShortWord | test | func isShortWord(w *snowballword.SnowballWord) (isShort bool) {
// If r1 is not empty, the word is not short
if w.R1start < len(w.RS) {
return
}
// Otherwise it must end in a short syllable
return endsShortSyllable(w, len(w.RS))
} | go | {
"resource": ""
} |
q180176 | step1a | test | func step1a(w *snowballword.SnowballWord) bool {
suffix, suffixRunes := w.FirstSuffix("sses", "ied", "ies", "us", "ss", "s")
switch suffix {
case "sses":
// Replace by ss
w.ReplaceSuffixRunes(suffixRunes, []rune("ss"), true)
return true
case "ies", "ied":
// Replace by i if preceded by more than one le... | go | {
"resource": ""
} |
q180177 | Set | test | func Set(key string, value interface{}) {
gid := curGoroutineID()
dataLock.Lock()
if data[gid] == nil {
data[gid] = Values{}
}
data[gid][key] = value
dataLock.Unlock()
} | go | {
"resource": ""
} |
q180178 | Get | test | func Get(key string) interface{} {
gid := curGoroutineID()
dataLock.RLock()
if data[gid] == nil {
dataLock.RUnlock()
return nil
}
value := data[gid][key]
dataLock.RUnlock()
return value
} | go | {
"resource": ""
} |
q180179 | Cleanup | test | func Cleanup() {
gid := curGoroutineID()
dataLock.Lock()
delete(data, gid)
dataLock.Unlock()
} | go | {
"resource": ""
} |
q180180 | getValues | test | func getValues() Values {
gid := curGoroutineID()
dataLock.Lock()
values := data[gid]
dataLock.Unlock()
return values
} | go | {
"resource": ""
} |
q180181 | linkGRs | test | func linkGRs(parentData Values) {
childID := curGoroutineID()
dataLock.Lock()
data[childID] = parentData
dataLock.Unlock()
} | go | {
"resource": ""
} |
q180182 | unlinkGRs | test | func unlinkGRs() {
childID := curGoroutineID()
dataLock.Lock()
delete(data, childID)
dataLock.Unlock()
} | go | {
"resource": ""
} |
q180183 | AppUri | test | func AppUri(appName, path string, config helpersinternal.CurlConfig) string {
uriCreator := &helpersinternal.AppUriCreator{CurlConfig: config}
return uriCreator.AppUri(appName, path)
} | go | {
"resource": ""
} |
q180184 | CurlAppWithTimeout | test | func CurlAppWithTimeout(cfg helpersinternal.CurlConfig, appName, path string, timeout time.Duration, args ...string) string {
appCurler := helpersinternal.NewAppCurler(Curl, cfg)
return appCurler.CurlAndWait(cfg, appName, path, timeout, args...)
} | go | {
"resource": ""
} |
q180185 | CurlApp | test | func CurlApp(cfg helpersinternal.CurlConfig, appName, path string, args ...string) string {
appCurler := helpersinternal.NewAppCurler(Curl, cfg)
return appCurler.CurlAndWait(cfg, appName, path, CURL_TIMEOUT, args...)
} | go | {
"resource": ""
} |
q180186 | CurlAppRoot | test | func CurlAppRoot(cfg helpersinternal.CurlConfig, appName string) string {
appCurler := helpersinternal.NewAppCurler(Curl, cfg)
return appCurler.CurlAndWait(cfg, appName, "/", CURL_TIMEOUT)
} | go | {
"resource": ""
} |
q180187 | GetTags | test | func GetTags(prefix rune, str string, terminator ...rune) (tags []Tag) {
// If we have no terminators given, default to only whitespace
if len(terminator) == 0 {
terminator = []rune(" ")
}
// get list of indexes in our str that is a terminator
// Always include the beginning of our str a terminator. This is so w... | go | {
"resource": ""
} |
q180188 | GetTagsAsUniqueStrings | test | func GetTagsAsUniqueStrings(prefix rune, str string, terminator ...rune) (strs []string) {
tags := GetTags(prefix, str, terminator...)
for _, tag := range tags {
strs = append(strs, tag.Tag)
}
return uniquify(strs)
} | go | {
"resource": ""
} |
q180189 | isTerminator | test | func isTerminator(r rune, terminator ...rune) bool {
for _, t := range terminator {
if r == t {
return true
}
}
return unicode.IsSpace(r) || !unicode.IsPrint(r)
} | go | {
"resource": ""
} |
q180190 | uniquify | test | func uniquify(in []string) (out []string) {
for _, i := range in {
if i == "" {
continue
}
for _, o := range out {
if i == o {
continue
}
}
out = append(out, i)
}
return
} | go | {
"resource": ""
} |
q180191 | New | test | func New(config Config) gin.HandlerFunc {
location := newLocation(config)
return func(c *gin.Context) {
location.applyToContext(c)
}
} | go | {
"resource": ""
} |
q180192 | Get | test | func Get(c *gin.Context) *url.URL {
v, ok := c.Get(key)
if !ok {
return nil
}
vv, ok := v.(*url.URL)
if !ok {
return nil
}
return vv
} | go | {
"resource": ""
} |
q180193 | GenerateRSAKeyPair | test | func GenerateRSAKeyPair(bits int, src io.Reader) (PrivKey, PubKey, error) {
if bits < 512 {
return nil, nil, ErrRsaKeyTooSmall
}
priv, err := rsa.GenerateKey(src, bits)
if err != nil {
return nil, nil, err
}
pk := &priv.PublicKey
return &RsaPrivateKey{sk: priv}, &RsaPublicKey{pk}, nil
} | go | {
"resource": ""
} |
q180194 | Verify | test | func (pk *RsaPublicKey) Verify(data, sig []byte) (bool, error) {
hashed := sha256.Sum256(data)
err := rsa.VerifyPKCS1v15(pk.k, crypto.SHA256, hashed[:], sig)
if err != nil {
return false, err
}
return true, nil
} | go | {
"resource": ""
} |
q180195 | Encrypt | test | func (pk *RsaPublicKey) Encrypt(b []byte) ([]byte, error) {
return rsa.EncryptPKCS1v15(rand.Reader, pk.k, b)
} | go | {
"resource": ""
} |
q180196 | Sign | test | func (sk *RsaPrivateKey) Sign(message []byte) ([]byte, error) {
hashed := sha256.Sum256(message)
return rsa.SignPKCS1v15(rand.Reader, sk.sk, crypto.SHA256, hashed[:])
} | go | {
"resource": ""
} |
q180197 | GetPublic | test | func (sk *RsaPrivateKey) GetPublic() PubKey {
if sk.pk == nil {
sk.pk = &sk.sk.PublicKey
}
return &RsaPublicKey{sk.pk}
} | go | {
"resource": ""
} |
q180198 | Decrypt | test | func (sk *RsaPrivateKey) Decrypt(b []byte) ([]byte, error) {
return rsa.DecryptPKCS1v15(rand.Reader, sk.sk, b)
} | go | {
"resource": ""
} |
q180199 | UnmarshalRsaPrivateKey | test | func UnmarshalRsaPrivateKey(b []byte) (PrivKey, error) {
sk, err := x509.ParsePKCS1PrivateKey(b)
if err != nil {
return nil, err
}
if sk.N.BitLen() < 512 {
return nil, ErrRsaKeyTooSmall
}
return &RsaPrivateKey{sk: sk}, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.