_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q172900 | WithCid | validation | func (o *GetVMByCidParams) WithCid(cid int32) *GetVMByCidParams {
o.SetCid(cid)
return o
} | go | {
"resource": ""
} |
q172901 | Validate | validation | func (m *VMResponse) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateVM(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | {
"resource": ""
} |
q172902 | LoadCodec | validation | func LoadCodec(bank string) (codec *WordCodec, err error) {
words, err := loadBank(bank)
if err != nil {
return codec, err
}
return NewCodec(words)
} | go | {
"resource": ""
} |
q172903 | MustLoadCodec | validation | func MustLoadCodec(bank string) *WordCodec {
codec, err := LoadCodec(bank)
if err != nil {
panic(err)
}
return codec
} | go | {
"resource": ""
} |
q172904 | loadBank | validation | func loadBank(bank string) ([]string, error) {
filename := "keys/words/wordlist/" + bank + ".txt"
words, err := wordlist.Asset(filename)
if err != nil {
return nil, err
}
wordsAll := strings.Split(strings.TrimSpace(string(words)), "\n")
return wordsAll, nil
} | go | {
"resource": ""
} |
q172905 | bytelenFromWords | validation | func bytelenFromWords(numWords int) (length int, maybeShorter bool) {
// calculate the max number of complete bytes we could store in this word
length = 11 * numWords / 8
// if one less byte would also generate this length, set maybeShorter
if wordlenFromBytes(length-1) == numWords {
maybeShorter = true
}
retur... | go | {
"resource": ""
} |
q172906 | GetIndex | validation | func (c *WordCodec) GetIndex(word string) (int, error) {
// generate the first time
if c.bytes == nil {
b := map[string]int{}
for i, w := range c.words {
if _, ok := b[w]; ok {
return -1, errors.Errorf("Duplicate word in list: %s", w)
}
b[w] = i
}
c.bytes = b
}
// get the index, or an error
r... | go | {
"resource": ""
} |
q172907 | Sum | validation | func Sum(bz []byte) []byte {
hash := sha256.Sum256(bz)
return hash[:Size]
} | go | {
"resource": ""
} |
q172908 | Equals | validation | func (privKey PrivKeyEd25519) Equals(other PrivKey) bool {
if otherEd, ok := other.(PrivKeyEd25519); ok {
return subtle.ConstantTimeCompare(privKey[:], otherEd[:]) == 1
} else {
return false
}
} | go | {
"resource": ""
} |
q172909 | Generate | validation | func (privKey PrivKeyEd25519) Generate(index int) PrivKeyEd25519 {
bz, err := cdc.MarshalBinaryBare(struct {
PrivKey [64]byte
Index int
}{privKey, index})
if err != nil {
panic(err)
}
newBytes := Sha256(bz)
newKey := new([64]byte)
copy(newKey[:32], newBytes)
ed25519.MakePublicKey(newKey)
return PrivKey... | go | {
"resource": ""
} |
q172910 | Set | validation | func (sm *simpleMap) Set(key string, value Hasher) {
sm.sorted = false
// The value is hashed, so you can
// check for equality with a cached value (say)
// and make a determination to fetch or not.
vhash := value.Hash()
sm.kvs = append(sm.kvs, cmn.KVPair{
Key: []byte(key),
Value: vhash,
})
} | go | {
"resource": ""
} |
q172911 | NewPrivKeyLedgerSecp256k1 | validation | func NewPrivKeyLedgerSecp256k1(path DerivationPath) (PrivKey, error) {
var pk PrivKeyLedgerSecp256k1
pk.Path = path
// cache the pubkey for later use
pubKey, err := pk.getPubKey()
if err != nil {
return nil, err
}
pk.CachedPubKey = pubKey
return &pk, err
} | go | {
"resource": ""
} |
q172912 | ValidateKey | validation | func (pk PrivKeyLedgerSecp256k1) ValidateKey() error {
// getPubKey will return an error if the ledger is not
pub, err := pk.getPubKey()
if err != nil {
return err
}
// verify this matches cached address
if !pub.Equals(pk.CachedPubKey) {
return fmt.Errorf("cached key does not match retrieved key")
}
return ... | go | {
"resource": ""
} |
q172913 | Sign | validation | func (pk PrivKeyLedgerSecp256k1) Sign(msg []byte) (Signature, error) {
dev, err := getLedger()
if err != nil {
return nil, err
}
sig, err := signLedgerSecp256k1(dev, pk.Path, msg)
if err != nil {
return nil, err
}
return sig, nil
} | go | {
"resource": ""
} |
q172914 | getPubKey | validation | func (pk PrivKeyLedgerSecp256k1) getPubKey() (key PubKey, err error) {
dev, err := getLedger()
if err != nil {
return key, fmt.Errorf("cannot connect to Ledger device - error: %v", err)
}
key, err = pubkeyLedgerSecp256k1(dev, pk.Path)
if err != nil {
return key, fmt.Errorf("please open Cosmos app on the Ledger... | go | {
"resource": ""
} |
q172915 | Equals | validation | func (pk PrivKeyLedgerSecp256k1) Equals(other PrivKey) bool {
if ledger, ok := other.(*PrivKeyLedgerSecp256k1); ok {
return pk.CachedPubKey.Equals(ledger.CachedPubKey)
}
return false
} | go | {
"resource": ""
} |
q172916 | SimpleHashFromHashers | validation | func SimpleHashFromHashers(items []Hasher) []byte {
hashes := make([][]byte, len(items))
for i, item := range items {
hash := item.Hash()
hashes[i] = hash
}
return simpleHashFromHashes(hashes)
} | go | {
"resource": ""
} |
q172917 | Verify | validation | func (sp *SimpleProof) Verify(index int, total int, leafHash []byte, rootHash []byte) bool {
computedHash := computeHashFromAunts(index, total, leafHash, sp.Aunts)
return computedHash != nil && bytes.Equal(computedHash, rootHash)
} | go | {
"resource": ""
} |
q172918 | computeHashFromAunts | validation | func computeHashFromAunts(index int, total int, leafHash []byte, innerHashes [][]byte) []byte {
if index >= total || index < 0 || total <= 0 {
return nil
}
switch total {
case 0:
panic("Cannot call computeHashFromAunts() with 0 total")
case 1:
if len(innerHashes) != 0 {
return nil
}
return leafHash
d... | go | {
"resource": ""
} |
q172919 | ComputePrivateKey | validation | func ComputePrivateKey(mprivHex string, chainHex string, path string, index int32) string {
privKeyBytes := DerivePrivateKeyForPath(
HexDecode(mprivHex),
HexDecode(chainHex),
fmt.Sprintf("%v/%v", path, index),
)
return HexEncode(privKeyBytes)
} | go | {
"resource": ""
} |
q172920 | ComputeBTCAddressForPrivKey | validation | func ComputeBTCAddressForPrivKey(privKey string) string {
pubKeyBytes := PubKeyBytesFromPrivKeyBytes(HexDecode(privKey), true)
return BTCAddrFromPubKeyBytes(pubKeyBytes)
} | go | {
"resource": ""
} |
q172921 | SignBTCMessage | validation | func SignBTCMessage(privKey string, message string, compress bool) string {
prefixBytes := []byte("Bitcoin Signed Message:\n")
messageBytes := []byte(message)
bytes := []byte{}
bytes = append(bytes, byte(len(prefixBytes)))
bytes = append(bytes, prefixBytes...)
bytes = append(bytes, byte(len(messageBytes)))
bytes... | go | {
"resource": ""
} |
q172922 | ComputeMastersFromSeed | validation | func ComputeMastersFromSeed(seed string) (string, string, string) {
key, data := []byte("Bitcoin seed"), []byte(seed)
secret, chain := I64(key, data)
pubKeyBytes := PubKeyBytesFromPrivKeyBytes(secret, true)
return HexEncode(pubKeyBytes), HexEncode(secret), HexEncode(chain)
} | go | {
"resource": ""
} |
q172923 | ComputeWIF | validation | func ComputeWIF(privKey string, compress bool) string {
return WIFFromPrivKeyBytes(HexDecode(privKey), compress)
} | go | {
"resource": ""
} |
q172924 | DerivePublicKeyForPath | validation | func DerivePublicKeyForPath(pubKeyBytes []byte, chainCode []byte, path string) []byte {
data := pubKeyBytes
parts := strings.Split(path, "/")
for _, part := range parts {
prime := part[len(part)-1:] == "'"
if prime {
panic(errors.New("cannot do a prime derivation from public key"))
}
i, err := strconv.Ato... | go | {
"resource": ""
} |
q172925 | DerivePrivateKey | validation | func DerivePrivateKey(privKeyBytes []byte, chainCode []byte, index uint32, prime bool) ([]byte, []byte) {
var data []byte
if prime {
index = index | 0x80000000
data = append([]byte{byte(0)}, privKeyBytes...)
} else {
public := PubKeyBytesFromPrivKeyBytes(privKeyBytes, true)
data = public
}
data = append(da... | go | {
"resource": ""
} |
q172926 | DerivePublicKey | validation | func DerivePublicKey(pubKeyBytes []byte, chainCode []byte, index uint32) ([]byte, []byte) {
data := []byte{}
data = append(data, pubKeyBytes...)
data = append(data, uint32ToBytes(index)...)
data2, chainCode2 := I64(chainCode, data)
data2p := PubKeyBytesFromPrivKeyBytes(data2, true)
return addPoints(pubKeyBytes, d... | go | {
"resource": ""
} |
q172927 | addPoints | validation | func addPoints(a []byte, b []byte) []byte {
ap, err := btcec.ParsePubKey(a, btcec.S256())
if err != nil {
panic(err)
}
bp, err := btcec.ParsePubKey(b, btcec.S256())
if err != nil {
panic(err)
}
sumX, sumY := btcec.S256().Add(ap.X, ap.Y, bp.X, bp.Y)
sum := &btcec.PublicKey{
Curve: btcec.S256(),
X: su... | go | {
"resource": ""
} |
q172928 | addScalars | validation | func addScalars(a []byte, b []byte) []byte {
aInt := new(big.Int).SetBytes(a)
bInt := new(big.Int).SetBytes(b)
sInt := new(big.Int).Add(aInt, bInt)
x := sInt.Mod(sInt, btcec.S256().N).Bytes()
x2 := [32]byte{}
copy(x2[32-len(x):], x)
return x2[:]
} | go | {
"resource": ""
} |
q172929 | HexDecode | validation | func HexDecode(str string) []byte {
b, _ := hex.DecodeString(str)
return b
} | go | {
"resource": ""
} |
q172930 | I64 | validation | func I64(key []byte, data []byte) ([]byte, []byte) {
mac := hmac.New(sha512.New, key)
mac.Write(data)
I := mac.Sum(nil)
return I[:32], I[32:]
} | go | {
"resource": ""
} |
q172931 | BTCAddrFromPubKeyBytes | validation | func BTCAddrFromPubKeyBytes(pubKeyBytes []byte) string {
versionPrefix := btcPrefixPubKeyHash // TODO Make const or configurable
h160 := CalcHash160(pubKeyBytes)
h160 = append([]byte{versionPrefix}, h160...)
checksum := CalcHash256(h160)
b := append(h160, checksum[:4]...)
return base58.Encode(b)
} | go | {
"resource": ""
} |
q172932 | BTCAddrBytesFromPubKeyBytes | validation | func BTCAddrBytesFromPubKeyBytes(pubKeyBytes []byte) (addrBytes []byte, checksum []byte) {
versionPrefix := btcPrefixPubKeyHash // TODO Make const or configurable
h160 := CalcHash160(pubKeyBytes)
_h160 := append([]byte{versionPrefix}, h160...)
checksum = CalcHash256(_h160)[:4]
return h160, checksum
} | go | {
"resource": ""
} |
q172933 | WIFFromPrivKeyBytes | validation | func WIFFromPrivKeyBytes(privKeyBytes []byte, compress bool) string {
versionPrefix := btcPrefixPrivKey // TODO Make const or configurable
bytes := append([]byte{versionPrefix}, privKeyBytes...)
if compress {
bytes = append(bytes, byte(1))
}
checksum := CalcHash256(bytes)
bytes = append(bytes, checksum[:4]...)
... | go | {
"resource": ""
} |
q172934 | PubKeyBytesFromPrivKeyBytes | validation | func PubKeyBytesFromPrivKeyBytes(privKeyBytes []byte, compress bool) (pubKeyBytes []byte) {
x, y := btcec.S256().ScalarBaseMult(privKeyBytes)
pub := &btcec.PublicKey{
Curve: btcec.S256(),
X: x,
Y: y,
}
if compress {
return pub.SerializeCompressed()
}
return pub.SerializeUncompressed()
} | go | {
"resource": ""
} |
q172935 | ReverseBytes | validation | func ReverseBytes(buf []byte) []byte {
var res []byte
if len(buf) == 0 {
return res
}
// Walk till mid-way, swapping bytes from each end:
// b[i] and b[len-i-1]
blen := len(buf)
res = make([]byte, blen)
mid := blen / 2
for left := 0; left <= mid; left++ {
right := blen - left - 1
res[left] = buf[right]
... | go | {
"resource": ""
} |
q172936 | getLedger | validation | func getLedger() (*ledger.Ledger, error) {
var err error
if device == nil {
device, err = ledger.FindLedger()
}
return device, err
} | go | {
"resource": ""
} |
q172937 | CreateLedger | validation | func (kb dbKeybase) CreateLedger(name string, path crypto.DerivationPath, algo SignAlgo) (Info, error) {
if algo != AlgoSecp256k1 {
return nil, fmt.Errorf("Only secp256k1 is supported for Ledger devices")
}
priv, err := crypto.NewPrivKeyLedgerSecp256k1(path)
if err != nil {
return nil, err
}
pub := priv.PubKe... | go | {
"resource": ""
} |
q172938 | CreateOffline | validation | func (kb dbKeybase) CreateOffline(name string, pub crypto.PubKey) (Info, error) {
return kb.writeOfflineKey(pub, name), nil
} | go | {
"resource": ""
} |
q172939 | Recover | validation | func (kb dbKeybase) Recover(name, passphrase, seedphrase string) (Info, error) {
words := strings.Split(strings.TrimSpace(seedphrase), " ")
secret, err := kb.codec.WordsToBytes(words)
if err != nil {
return nil, err
}
// secret is comprised of the actual secret with the type
// appended.
// ie [secret] = [typ... | go | {
"resource": ""
} |
q172940 | List | validation | func (kb dbKeybase) List() ([]Info, error) {
var res []Info
iter := kb.db.Iterator(nil, nil)
defer iter.Close()
for ; iter.Valid(); iter.Next() {
info, err := readInfo(iter.Value())
if err != nil {
return nil, err
}
res = append(res, info)
}
return res, nil
} | go | {
"resource": ""
} |
q172941 | Get | validation | func (kb dbKeybase) Get(name string) (Info, error) {
bs := kb.db.Get(infoKey(name))
return readInfo(bs)
} | go | {
"resource": ""
} |
q172942 | Sign | validation | func (kb dbKeybase) Sign(name, passphrase string, msg []byte) (sig crypto.Signature, pub crypto.PubKey, err error) {
info, err := kb.Get(name)
if err != nil {
return
}
var priv crypto.PrivKey
switch info.(type) {
case localInfo:
linfo := info.(localInfo)
if linfo.PrivKeyArmor == "" {
err = fmt.Errorf("pr... | go | {
"resource": ""
} |
q172943 | ExportPubKey | validation | func (kb dbKeybase) ExportPubKey(name string) (armor string, err error) {
bz := kb.db.Get(infoKey(name))
if bz == nil {
return "", errors.New("No key to export with name " + name)
}
info, err := readInfo(bz)
if err != nil {
return
}
return armorPubKeyBytes(info.GetPubKey().Bytes()), nil
} | go | {
"resource": ""
} |
q172944 | ImportPubKey | validation | func (kb dbKeybase) ImportPubKey(name string, armor string) (err error) {
bz := kb.db.Get(infoKey(name))
if len(bz) > 0 {
return errors.New("Cannot overwrite data for name " + name)
}
pubBytes, err := unarmorPubKeyBytes(armor)
if err != nil {
return
}
pubKey, err := crypto.PubKeyFromBytes(pubBytes)
if err !... | go | {
"resource": ""
} |
q172945 | Update | validation | func (kb dbKeybase) Update(name, oldpass, newpass string) error {
info, err := kb.Get(name)
if err != nil {
return err
}
switch info.(type) {
case localInfo:
linfo := info.(localInfo)
key, err := unarmorDecryptPrivKey(linfo.PrivKeyArmor, oldpass)
if err != nil {
return err
}
kb.writeLocalKey(key, na... | go | {
"resource": ""
} |
q172946 | randBytes | validation | func randBytes(numBytes int) []byte {
b := make([]byte, numBytes)
_, err := crand.Read(b)
if err != nil {
PanicCrisis(err)
}
return b
} | go | {
"resource": ""
} |
q172947 | GenerateFromPassword | validation | func GenerateFromPassword(salt []byte, password []byte, cost int) ([]byte, error) {
if len(salt) != maxSaltSize {
return nil, fmt.Errorf("Salt len must be %v", maxSaltSize)
}
p, err := newFromPassword(salt, password, cost)
if err != nil {
return nil, err
}
return p.Hash(), nil
} | go | {
"resource": ""
} |
q172948 | CompareHashAndPassword | validation | func CompareHashAndPassword(hashedPassword, password []byte) error {
p, err := newFromHash(hashedPassword)
if err != nil {
return err
}
otherHash, err := bcrypt(password, p.cost, p.salt)
if err != nil {
return err
}
otherP := &hashed{otherHash, p.salt, p.cost, p.major, p.minor}
if subtle.ConstantTimeCompa... | go | {
"resource": ""
} |
q172949 | Cost | validation | func Cost(hashedPassword []byte) (int, error) {
p, err := newFromHash(hashedPassword)
if err != nil {
return 0, err
}
return p.cost, nil
} | go | {
"resource": ""
} |
q172950 | decodeCost | validation | func (p *hashed) decodeCost(sbytes []byte) (int, error) {
cost, err := strconv.Atoi(string(sbytes[0:2]))
if err != nil {
return -1, err
}
err = checkCost(cost)
if err != nil {
return -1, err
}
p.cost = cost
return 3, nil
} | go | {
"resource": ""
} |
q172951 | ASTToString | validation | func ASTToString(a AST, options ...Option) string {
tparams := true
for _, o := range options {
switch o {
case NoTemplateParams:
tparams = false
}
}
ps := printState{tparams: tparams}
a.print(&ps)
return ps.buf.String()
} | go | {
"resource": ""
} |
q172952 | writeByte | validation | func (ps *printState) writeByte(b byte) {
ps.last = b
ps.buf.WriteByte(b)
} | go | {
"resource": ""
} |
q172953 | writeString | validation | func (ps *printState) writeString(s string) {
if len(s) > 0 {
ps.last = s[len(s)-1]
}
ps.buf.WriteString(s)
} | go | {
"resource": ""
} |
q172954 | print | validation | func (ps *printState) print(a AST) {
c := 0
for _, v := range ps.printing {
if v == a {
// We permit the type to appear once, and
// return without printing anything if we see
// it twice. This is for a case like
// _Z6outer2IsEPFilES1_, where the
// substitution is printed differently the
// sec... | go | {
"resource": ""
} |
q172955 | printInner | validation | func (twq *TypeWithQualifiers) printInner(ps *printState) {
ps.writeByte(' ')
ps.writeString(strings.Join(twq.Qualifiers, " "))
} | go | {
"resource": ""
} |
q172956 | printBase | validation | func printBase(ps *printState, qual, base AST) {
ps.inner = append(ps.inner, qual)
ps.print(base)
if len(ps.inner) > 0 {
qual.(innerPrinter).printInner(ps)
ps.inner = ps.inner[:len(ps.inner)-1]
}
} | go | {
"resource": ""
} |
q172957 | printDimension | validation | func (at *ArrayType) printDimension(ps *printState) {
space := " "
for len(ps.inner) > 0 {
// We haven't gotten to the real type yet. Use
// parentheses around that type, except that if it is
// an array type we print it as a multi-dimensional
// array
in := ps.inner[len(ps.inner)-1]
if twq, ok := in.(*T... | go | {
"resource": ""
} |
q172958 | printArgs | validation | func (ft *FunctionType) printArgs(ps *printState) {
paren := false
space := false
for i := len(ps.inner) - 1; i >= 0; i-- {
switch ps.inner[i].(type) {
case *PointerType, *ReferenceType, *RvalueReferenceType:
paren = true
case *TypeWithQualifiers, *ComplexType, *ImaginaryType, *PtrMem:
space = true
pa... | go | {
"resource": ""
} |
q172959 | parenthesize | validation | func parenthesize(ps *printState, val AST) {
paren := false
switch v := val.(type) {
case *Name, *InitializerList, *FunctionParam:
case *Qualified:
if v.LocalName {
paren = true
}
default:
paren = true
}
if paren {
ps.writeByte('(')
}
ps.print(val)
if paren {
ps.writeByte(')')
}
} | go | {
"resource": ""
} |
q172960 | printInner | validation | func (ps *printState) printInner(prefixOnly bool) []AST {
var save []AST
var psave *[]AST
if prefixOnly {
psave = &save
}
for len(ps.inner) > 0 {
ps.printOneInner(psave)
}
return save
} | go | {
"resource": ""
} |
q172961 | printOneInner | validation | func (ps *printState) printOneInner(save *[]AST) {
if len(ps.inner) == 0 {
panic("printOneInner called with no inner types")
}
ln := len(ps.inner)
a := ps.inner[ln-1]
ps.inner = ps.inner[:ln-1]
if save != nil {
if _, ok := a.(*MethodWithQualifiers); ok {
*save = append(*save, a)
return
}
}
if ip, ... | go | {
"resource": ""
} |
q172962 | isEmpty | validation | func (ps *printState) isEmpty(a AST) bool {
switch a := a.(type) {
case *ArgumentPack:
return len(a.Args) == 0
case *ExprList:
return len(a.Exprs) == 0
case *PackExpansion:
return a.Pack != nil && ps.isEmpty(a.Base)
default:
return false
}
} | go | {
"resource": ""
} |
q172963 | Filter | validation | func Filter(name string, options ...Option) string {
ret, err := ToString(name, options...)
if err != nil {
return name
}
return ret
} | go | {
"resource": ""
} |
q172964 | ToString | validation | func ToString(name string, options ...Option) (string, error) {
a, err := ToAST(name, options...)
if err != nil {
return "", err
}
return ASTToString(a, options...), nil
} | go | {
"resource": ""
} |
q172965 | ToAST | validation | func ToAST(name string, options ...Option) (AST, error) {
if strings.HasPrefix(name, "_Z") {
a, err := doDemangle(name[2:], options...)
return a, adjustErr(err, 2)
}
const prefix = "_GLOBAL_"
if strings.HasPrefix(name, prefix) {
// The standard demangler ignores NoParams for global
// constructors. We are... | go | {
"resource": ""
} |
q172966 | doDemangle | validation | func doDemangle(name string, options ...Option) (ret AST, err error) {
// When the demangling routines encounter an error, they panic
// with a value of type demangleErr.
defer func() {
if r := recover(); r != nil {
if de, ok := r.(demangleErr); ok {
ret = nil
err = de
return
}
panic(r)
}
}... | go | {
"resource": ""
} |
q172967 | copy | validation | func (st *state) copy() *state {
n := new(state)
*n = *st
return n
} | go | {
"resource": ""
} |
q172968 | fail | validation | func (st *state) fail(err string) {
panic(demangleErr{err: err, off: st.off})
} | go | {
"resource": ""
} |
q172969 | failEarlier | validation | func (st *state) failEarlier(err string, dec int) {
if st.off < dec {
panic("internal error")
}
panic(demangleErr{err: err, off: st.off - dec})
} | go | {
"resource": ""
} |
q172970 | advance | validation | func (st *state) advance(add int) {
if len(st.str) < add {
panic("internal error")
}
st.str = st.str[add:]
st.off += add
} | go | {
"resource": ""
} |
q172971 | checkChar | validation | func (st *state) checkChar(c byte) {
if len(st.str) == 0 || st.str[0] != c {
panic("internal error")
}
st.advance(1)
} | go | {
"resource": ""
} |
q172972 | Error | validation | func (de demangleErr) Error() string {
return fmt.Sprintf("%s at %d", de.err, de.off)
} | go | {
"resource": ""
} |
q172973 | adjustErr | validation | func adjustErr(err error, adj int) error {
if err == nil {
return nil
}
if de, ok := err.(demangleErr); ok {
de.off += adj
return de
}
return err
} | go | {
"resource": ""
} |
q172974 | hasReturnType | validation | func hasReturnType(a AST) bool {
switch a := a.(type) {
case *Template:
return !isCDtorConversion(a.Name)
case *TypeWithQualifiers:
return hasReturnType(a.Base)
case *MethodWithQualifiers:
return hasReturnType(a.Method)
default:
return false
}
} | go | {
"resource": ""
} |
q172975 | isCDtorConversion | validation | func isCDtorConversion(a AST) bool {
switch a := a.(type) {
case *Qualified:
return isCDtorConversion(a.Name)
case *Constructor, *Destructor, *Cast:
return true
default:
return false
}
} | go | {
"resource": ""
} |
q172976 | javaResource | validation | func (st *state) javaResource() AST {
off := st.off
ln := st.number()
if ln <= 1 {
st.failEarlier("java resource length less than 1", st.off-off)
}
if len(st.str) == 0 || st.str[0] != '_' {
st.fail("expected _ after number")
}
st.advance(1)
ln--
if len(st.str) < ln {
st.fail("not enough characters for ja... | go | {
"resource": ""
} |
q172977 | mergeQualifiers | validation | func mergeQualifiers(q1, q2 Qualifiers) Qualifiers {
m := make(map[string]bool)
for _, qual := range q1 {
m[qual] = true
}
for _, qual := range q2 {
if !m[qual] {
q1 = append(q1, qual)
m[qual] = true
}
}
return q1
} | go | {
"resource": ""
} |
q172978 | setTemplate | validation | func (st *state) setTemplate(a AST, tmpl *Template) {
var seen []AST
a.Traverse(func(a AST) bool {
switch a := a.(type) {
case *TemplateParam:
if a.Template != nil {
if tmpl != nil {
st.fail("duplicate template parameters")
}
return false
}
if tmpl == nil {
st.fail("cast template par... | go | {
"resource": ""
} |
q172979 | clearTemplateArgs | validation | func (st *state) clearTemplateArgs(args []AST) {
for _, a := range args {
st.setTemplate(a, nil)
}
} | go | {
"resource": ""
} |
q172980 | exprList | validation | func (st *state) exprList(stop byte) AST {
if len(st.str) > 0 && st.str[0] == stop {
st.advance(1)
return &ExprList{Exprs: nil}
}
var exprs []AST
for {
e := st.expression()
exprs = append(exprs, e)
if len(st.str) > 0 && st.str[0] == stop {
st.advance(1)
break
}
}
return &ExprList{Exprs: exprs}
... | go | {
"resource": ""
} |
q172981 | cloneSuffix | validation | func (st *state) cloneSuffix(a AST) AST {
i := 0
if len(st.str) > 1 && st.str[0] == '.' && (isLower(st.str[1]) || st.str[1] == '_') {
i += 2
for len(st.str) > i && (isLower(st.str[i]) || st.str[i] == '_') {
i++
}
}
for len(st.str) > i+1 && st.str[i] == '.' && isDigit(st.str[i+1]) {
i += 2
for len(st.st... | go | {
"resource": ""
} |
q172982 | simplify | validation | func simplify(a AST) AST {
var seen []AST
skip := func(a AST) bool {
for _, v := range seen {
if v == a {
return true
}
}
seen = append(seen, a)
return false
}
if r := a.Copy(simplifyOne, skip); r != nil {
return r
}
return a
} | go | {
"resource": ""
} |
q172983 | findArgumentPack | validation | func (st *state) findArgumentPack(a AST) *ArgumentPack {
var seen []AST
var ret *ArgumentPack
a.Traverse(func(a AST) bool {
if ret != nil {
return false
}
switch a := a.(type) {
case *TemplateParam:
if a.Template == nil || a.Index >= len(a.Template.Args) {
return true
}
if pack, ok := a.Templ... | go | {
"resource": ""
} |
q172984 | doDemangle | validation | func doDemangle(out *bufio.Writer, name string) {
skip := 0
if name[0] == '.' || name[0] == '$' {
skip++
}
if *stripUnderscore && name[skip] == '_' {
skip++
}
result := demangle.Filter(name[skip:], options()...)
if result == name[skip:] {
out.WriteString(name)
} else {
if name[0] == '.' {
out.WriteBy... | go | {
"resource": ""
} |
q172985 | options | validation | func options() []demangle.Option {
var options []demangle.Option
if *noParams {
options = append(options, demangle.NoParams)
}
if !*noVerbose {
options = append(options, demangle.Verbose)
}
return options
} | go | {
"resource": ""
} |
q172986 | MultipartForm | validation | func MultipartForm(formStruct interface{}, ifacePtr ...interface{}) martini.Handler {
return func(context martini.Context, req *http.Request) {
var errors Errors
ensureNotPointer(formStruct)
formStruct := reflect.New(reflect.TypeOf(formStruct))
// This if check is necessary due to https://github.com/martini-... | go | {
"resource": ""
} |
q172987 | Json | validation | func Json(jsonStruct interface{}, ifacePtr ...interface{}) martini.Handler {
return func(context martini.Context, req *http.Request) {
var errors Errors
ensureNotPointer(jsonStruct)
jsonStruct := reflect.New(reflect.TypeOf(jsonStruct))
if req.Body != nil {
defer req.Body.Close()
err := json.NewDecoder... | go | {
"resource": ""
} |
q172988 | validateStruct | validation | func validateStruct(errors Errors, obj interface{}) Errors {
typ := reflect.TypeOf(obj)
val := reflect.ValueOf(obj)
if typ.Kind() == reflect.Ptr {
typ = typ.Elem()
val = val.Elem()
}
for i := 0; i < typ.NumField(); i++ {
field := typ.Field(i)
// Skip ignored and unexported fields in the struct
if fiel... | go | {
"resource": ""
} |
q172989 | ErrorHandler | validation | func ErrorHandler(errs Errors, resp http.ResponseWriter) {
if len(errs) > 0 {
resp.Header().Set("Content-Type", jsonContentType)
if errs.Has(DeserializationError) {
resp.WriteHeader(http.StatusBadRequest)
} else if errs.Has(ContentTypeError) {
resp.WriteHeader(http.StatusUnsupportedMediaType)
} else {
... | go | {
"resource": ""
} |
q172990 | Get | validation | func (d *localeStore) Get(lang, section, format string) (string, bool) {
if locale, ok := d.store[lang]; ok {
if section == "" {
section = goconfig.DEFAULT_SECTION
}
if value, err := locale.message.GetValue(section, format); err == nil {
return value, true
}
}
return "", false
} | go | {
"resource": ""
} |
q172991 | SetMessage | validation | func SetMessage(lang, filePath string, appendFiles ...string) error {
return SetMessageWithDesc(lang, lang, filePath, appendFiles...)
} | go | {
"resource": ""
} |
q172992 | Idle | validation | func (c *Client) Idle(stop <-chan struct{}) error {
if c.LogoutTimeout == 0 {
return c.idle(stop)
}
t := time.NewTicker(c.LogoutTimeout)
defer t.Stop()
for {
stopOrRestart := make(chan struct{})
done := make(chan error, 1)
go func() {
done <- c.idle(stopOrRestart)
}()
select {
case <-t.C:
cl... | go | {
"resource": ""
} |
q172993 | IdleWithFallback | validation | func (c *Client) IdleWithFallback(stop <-chan struct{}, pollInterval time.Duration) error {
if ok, err := c.SupportIdle(); err != nil {
return err
} else if ok {
return c.Idle(stop)
}
if pollInterval == 0 {
pollInterval = defaultPollInterval
}
t := time.NewTicker(pollInterval)
defer t.Stop()
for {
se... | go | {
"resource": ""
} |
q172994 | putToBottom | validation | func (s *Sentinel) putToBottom(addr string) {
addrs := s.Addrs
if addrs[len(addrs)-1] == addr {
// Already on bottom.
return
}
newAddrs := []string{}
for _, a := range addrs {
if a == addr {
continue
}
newAddrs = append(newAddrs, a)
}
newAddrs = append(newAddrs, addr)
s.Addrs = newAddrs
} | go | {
"resource": ""
} |
q172995 | defaultPool | validation | func (s *Sentinel) defaultPool(addr string) *redis.Pool {
return &redis.Pool{
MaxIdle: 3,
MaxActive: 10,
Wait: true,
IdleTimeout: 240 * time.Second,
Dial: func() (redis.Conn, error) {
return s.Dial(addr)
},
TestOnBorrow: func(c redis.Conn, t time.Time) error {
_, err := c.Do("PING")
... | go | {
"resource": ""
} |
q172996 | close | validation | func (s *Sentinel) close() {
if s.pools != nil {
for _, pool := range s.pools {
pool.Close()
}
}
s.pools = nil
} | go | {
"resource": ""
} |
q172997 | MasterAddr | validation | func (s *Sentinel) MasterAddr() (string, error) {
res, err := s.doUntilSuccess(func(c redis.Conn) (interface{}, error) {
return queryForMaster(c, s.MasterName)
})
if err != nil {
return "", err
}
return res.(string), nil
} | go | {
"resource": ""
} |
q172998 | SlaveAddrs | validation | func (s *Sentinel) SlaveAddrs() ([]string, error) {
res, err := s.doUntilSuccess(func(c redis.Conn) (interface{}, error) {
return queryForSlaveAddrs(c, s.MasterName)
})
if err != nil {
return nil, err
}
return res.([]string), nil
} | go | {
"resource": ""
} |
q172999 | Addr | validation | func (s *Slave) Addr() string {
return net.JoinHostPort(s.ip, s.port)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.