_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q181900 | getenv | test | func getenv(name string) (s string, ok bool) {
m := make(map[string]bool)
for _, keyVal := range os.Environ() {
split := strings.Split(keyVal, "=")
m[split[0]] = true
}
name = flagAsEnv(name)
if _, ok = m[name]; ok {
s = os.Getenv(name)
}
return
} | go | {
"resource": ""
} |
q181901 | flagAsEnv | test | func flagAsEnv(name string) string {
name = strings.ToUpper(EnvPrefix + name)
name = strings.Replace(name, ".", "_", -1)
name = strings.Replace(name, "-", "_", -1)
return name
} | go | {
"resource": ""
} |
q181902 | NewPolicy | test | func NewPolicy() Policy {
p := Policy{
MinLength: 6,
MaxLength: 16,
MinLowers: 0,
MinUppers: 0,
MinDigits: 0,
MinSpclChars: 0,
LowerPool: "abcdefghijklmnopqrstuvwxyz",
UpperPool: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
DigitPool: "0123456789",
SpclCharPool: "!@#$%^&*()-_=+,.?/:;{}[]~"... | go | {
"resource": ""
} |
q181903 | CreateRandom | test | func CreateRandom(bs []byte, length int) []byte {
filled := make([]byte, length)
max := len(bs)
for i := 0; i < length; i++ {
Shuffle(bs)
filled[i] = bs[random(0, max)]
}
return filled
} | go | {
"resource": ""
} |
q181904 | Shuffle | test | func Shuffle(bs []byte) {
n := len(bs)
for i := n - 1; i > 0; i-- {
rand.Seed(time.Now().UnixNano())
j := rand.Intn(i + 1)
bs[i], bs[j] = bs[j], bs[i]
}
} | go | {
"resource": ""
} |
q181905 | Generate | test | func Generate(p Policy) (string, error) {
// Character length based policies should not be negative
if p.MinLength < 0 || p.MaxLength < 0 || p.MinUppers < 0 ||
p.MinLowers < 0 || p.MinDigits < 0 || p.MinSpclChars < 0 {
return "", ErrNegativeLengthNotAllowed
}
collectiveMinLength := p.MinUppers + p.MinLowers +... | go | {
"resource": ""
} |
q181906 | ExecutableFolder | test | func ExecutableFolder() (string, error) {
p, err := Executable()
if err != nil {
return "", err
}
folder, _ := filepath.Split(p)
return folder, nil
} | go | {
"resource": ""
} |
q181907 | Ignore | test | func Ignore(ignore ...func(error) bool) Option {
return func(s *Sentinel) error {
s.Lock()
defer s.Unlock()
if s.started {
return ErrAlreadyStarted
}
s.ignoreErrors = append(s.ignoreErrors, ignore...)
return nil
}
} | go | {
"resource": ""
} |
q181908 | Sigs | test | func Sigs(sigs ...os.Signal) Option {
return func(s *Sentinel) error {
s.Lock()
defer s.Unlock()
if s.started {
return ErrAlreadyStarted
}
s.shutdownSigs = sigs
return nil
}
} | go | {
"resource": ""
} |
q181909 | Logf | test | func Logf(f func(string, ...interface{})) Option {
return func(s *Sentinel) error {
s.logf = f
return nil
}
} | go | {
"resource": ""
} |
q181910 | Errorf | test | func Errorf(f func(string, ...interface{})) Option {
return func(s *Sentinel) error {
s.errf = f
return nil
}
} | go | {
"resource": ""
} |
q181911 | New | test | func New(opts ...Option) (*Sentinel, error) {
s := &Sentinel{
shutdownDuration: DefaultShutdownDuration,
logf: func(string, ...interface{}) {},
}
var err error
// apply options
for _, o := range opts {
if err = o(s); err != nil {
return nil, err
}
}
// ensure sigs set
if s.shutdownSigs... | go | {
"resource": ""
} |
q181912 | Run | test | func (s *Sentinel) Run(ctxt context.Context) error {
s.Lock()
if s.started {
defer s.Unlock()
return ErrAlreadyStarted
}
s.started = true
s.Unlock()
eg, ctxt := errgroup.WithContext(ctxt)
// add servers
for _, f := range s.serverFuncs {
eg.Go(func(f func(context.Context) error) func() error {
return ... | go | {
"resource": ""
} |
q181913 | Shutdown | test | func (s *Sentinel) Shutdown() error {
var firstErr error
for i, f := range s.shutdownFuncs {
ctxt, cancel := context.WithTimeout(context.Background(), s.shutdownDuration)
defer cancel()
if err := f(ctxt); err != nil {
s.errf("could not shutdown %d: %v", i, err)
if firstErr == nil {
firstErr = err
}... | go | {
"resource": ""
} |
q181914 | ShutdownIgnore | test | func (s *Sentinel) ShutdownIgnore(err error) bool {
if err == nil {
return true
}
for _, f := range s.ignoreErrors {
if z := f(err); z {
return true
}
}
return false
} | go | {
"resource": ""
} |
q181915 | Register | test | func (s *Sentinel) Register(server, shutdown interface{}, ignore ...func(error) bool) error {
// add server and shutdown funcs
var err error
s.serverFuncs, err = convertAndAppendContextFuncs(s.serverFuncs, server)
if err != nil {
return err
}
s.shutdownFuncs, err = convertAndAppendContextFuncs(s.shutdownFuncs, ... | go | {
"resource": ""
} |
q181916 | Mux | test | func (s *Sentinel) Mux(listener net.Listener, opts ...netmux.Option) (*netmux.Netmux, error) {
s.Lock()
defer s.Unlock()
if s.started {
return nil, ErrAlreadyStarted
}
// create connection mux
mux, err := netmux.New(listener, opts...)
if err != nil {
return nil, err
}
// register server + shutdown
if e... | go | {
"resource": ""
} |
q181917 | HTTP | test | func (s *Sentinel) HTTP(listener net.Listener, handler http.Handler, opts ...ServerOption) error {
s.Lock()
defer s.Unlock()
if s.started {
return ErrAlreadyStarted
}
var err error
// create server and apply options
server := &http.Server{
Handler: handler,
}
for _, o := range opts {
if err = o(server... | go | {
"resource": ""
} |
q181918 | IgnoreError | test | func IgnoreError(err error) func(error) bool {
return func(e error) bool {
return err == e
}
} | go | {
"resource": ""
} |
q181919 | IgnoreNetOpError | test | func IgnoreNetOpError(err error) bool {
if opErr, ok := err.(*net.OpError); ok {
return opErr.Err.Error() == "use of closed network connection"
}
return false
} | go | {
"resource": ""
} |
q181920 | convertAndAppendContextFuncs | test | func convertAndAppendContextFuncs(o []func(context.Context) error, v ...interface{}) ([]func(context.Context) error, error) {
for _, z := range v {
var t func(context.Context) error
switch f := z.(type) {
case func(context.Context) error:
t = f
case func():
t = func(context.Context) error {
f()
... | go | {
"resource": ""
} |
q181921 | router | test | func router(apiData []byte, services map[string]Service, healthHandler func(http.ResponseWriter, *http.Request)) *mux.Router {
m := mux.NewRouter()
gtgChecker := make([]gtg.StatusChecker, 0)
for path, service := range services {
handlers := httpHandlers{service}
m.HandleFunc(fmt.Sprintf("/%s/__count", path), h... | go | {
"resource": ""
} |
q181922 | buildInfoHandler | test | func buildInfoHandler(w http.ResponseWriter, req *http.Request) {
fmt.Fprintf(w, "build-info")
} | go | {
"resource": ""
} |
q181923 | Encode | test | func (_ JsonEncoder) Encode(v ...interface{}) ([]byte, error) {
var data interface{} = v
var result interface{}
if v == nil {
// So that empty results produces `[]` and not `null`
data = []interface{}{}
} else if len(v) == 1 {
data = v[0]
}
t := reflect.TypeOf(data)
if t.Kind() == reflect.Ptr {
t = t.... | go | {
"resource": ""
} |
q181924 | Json | test | func Json(jsonStruct interface{}, ifacePtr ...interface{}) martini.Handler {
return func(context martini.Context, req *http.Request) {
ensureNotPointer(jsonStruct)
jsonStruct := reflect.New(reflect.TypeOf(jsonStruct))
errors := newErrors()
if req.Body != nil {
defer req.Body.Close()
}
if err := json.N... | go | {
"resource": ""
} |
q181925 | validateAndMap | test | func validateAndMap(obj reflect.Value, context martini.Context, errors *Errors, ifacePtr ...interface{}) {
context.Invoke(Validate(obj.Interface()))
errors.combine(getErrors(context))
context.Map(*errors)
context.Map(obj.Elem().Interface())
if len(ifacePtr) > 0 {
context.MapTo(obj.Elem().Interface(), ifacePtr[0]... | go | {
"resource": ""
} |
q181926 | Count | test | func (self Errors) Count() int {
return len(self.Overall) + len(self.Fields)
} | go | {
"resource": ""
} |
q181927 | Header | test | func (o *Options) Header(origin string) (headers map[string]string) {
headers = make(map[string]string)
// if origin is not alowed, don't extend the headers
// with CORS headers.
if !o.AllowAllOrigins && !o.IsOriginAllowed(origin) {
return
}
// add allow origin
if o.AllowAllOrigins {
headers[headerAllowOrig... | go | {
"resource": ""
} |
q181928 | PreflightHeader | test | func (o *Options) PreflightHeader(origin, rMethod, rHeaders string) (headers map[string]string) {
headers = make(map[string]string)
if !o.AllowAllOrigins && !o.IsOriginAllowed(origin) {
return
}
// verify if requested method is allowed
// TODO: Too many for loops
for _, method := range o.AllowMethods {
if met... | go | {
"resource": ""
} |
q181929 | IsOriginAllowed | test | func (o *Options) IsOriginAllowed(origin string) (allowed bool) {
for _, pattern := range o.AllowOrigins {
allowed, _ = regexp.MatchString(pattern, origin)
if allowed {
return
}
}
return
} | go | {
"resource": ""
} |
q181930 | Allow | test | func Allow(opts *Options) http.HandlerFunc {
return func(res http.ResponseWriter, req *http.Request) {
var (
origin = req.Header.Get(headerOrigin)
requestedMethod = req.Header.Get(headerRequestMethod)
requestedHeaders = req.Header.Get(headerRequestHeaders)
// additional headers to be added
... | go | {
"resource": ""
} |
q181931 | Renderer | test | func Renderer(options ...Options) martini.Handler {
opt := prepareOptions(options)
cs := prepareCharset(opt.Charset)
t := compile(opt)
return func(res http.ResponseWriter, req *http.Request, c martini.Context) {
// recompile for easy development
if martini.Env == martini.Dev {
t = compile(opt)
}
tc, _ :=... | go | {
"resource": ""
} |
q181932 | String | test | func (al AcceptLanguages) String() string {
output := bytes.NewBufferString("")
for i, language := range al {
output.WriteString(fmt.Sprintf("%s (%1.1f)", language.Language, language.Quality))
if i != len(al)-1 {
output.WriteString(", ")
}
}
if output.Len() == 0 {
output.WriteString("[]")
}
return ou... | go | {
"resource": ""
} |
q181933 | Languages | test | func Languages() martini.Handler {
return func(context martini.Context, request *http.Request) {
header := request.Header.Get(acceptLanguageHeader)
if header != "" {
acceptLanguageHeaderValues := strings.Split(header, ",")
acceptLanguages := make(AcceptLanguages, len(acceptLanguageHeaderValues))
for i, l... | go | {
"resource": ""
} |
q181934 | Prefix | test | func Prefix(prefix string) martini.Handler {
return func(w http.ResponseWriter, r *http.Request) {
if prefix == "" {
return
}
if p := strings.TrimPrefix(r.URL.Path, prefix); len(p) < len(r.URL.Path) {
r.URL.Path = p
} else {
http.NotFound(w, r)
}
}
} | go | {
"resource": ""
} |
q181935 | Basic | test | func Basic(username string, password string) http.HandlerFunc {
var siteAuth = base64.StdEncoding.EncodeToString([]byte(username + ":" + password))
return func(res http.ResponseWriter, req *http.Request) {
auth := req.Header.Get("Authorization")
if !SecureCompare(auth, "Basic "+siteAuth) {
res.Header().Set("WW... | go | {
"resource": ""
} |
q181936 | UpdateUser | test | func UpdateUser(s sessions.Session, user User) error {
s.Set(SessionKey, user.UniqueId())
return nil
} | go | {
"resource": ""
} |
q181937 | GetById | test | func (u *MyUserModel) GetById(id interface{}) error {
err := dbmap.SelectOne(u, "SELECT * FROM users WHERE id = $1", id)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q181938 | AddressToAccountId | test | func AddressToAccountId(address string) (result xdr.AccountId, err error) {
bytes, err := strkey.Decode(strkey.VersionByteAccountID, address)
if err != nil {
return
}
var raw xdr.Uint256
copy(raw[:], bytes)
pk, err := xdr.NewPublicKey(xdr.CryptoKeyTypeKeyTypeEd25519, raw)
if err != nil {
return
}
resul... | go | {
"resource": ""
} |
q181939 | MutateChangeTrust | test | func (m Asset) MutateChangeTrust(o *xdr.ChangeTrustOp) (err error) {
if m.Native {
return errors.New("Native asset not allowed")
}
o.Line, err = m.ToXdrObject()
return
} | go | {
"resource": ""
} |
q181940 | MutateChangeTrust | test | func (m Limit) MutateChangeTrust(o *xdr.ChangeTrustOp) (err error) {
o.Limit, err = amount.Parse(string(m))
return
} | go | {
"resource": ""
} |
q181941 | Trust | test | func Trust(code, issuer string, args ...interface{}) (result ChangeTrustBuilder) {
mutators := []interface{}{
CreditAsset(code, issuer),
}
limitSet := false
for _, mut := range args {
mutators = append(mutators, mut)
_, isLimit := mut.(Limit)
if isLimit {
limitSet = true
}
}
if !limitSet {
mutat... | go | {
"resource": ""
} |
q181942 | RemoveTrust | test | func RemoveTrust(code, issuer string, args ...interface{}) (result ChangeTrustBuilder) {
mutators := []interface{}{
CreditAsset(code, issuer),
Limit("0"),
}
for _, mut := range args {
mutators = append(mutators, mut)
}
return ChangeTrust(mutators...)
} | go | {
"resource": ""
} |
q181943 | MutatePayment | test | func (m CreditAmount) MutatePayment(o interface{}) (err error) {
switch o := o.(type) {
default:
err = errors.New("Unexpected operation type")
case *xdr.PaymentOp:
o.Amount, err = amount.Parse(m.Amount)
if err != nil {
return
}
o.Asset, err = createAlphaNumAsset(m.Code, m.Issuer)
case *xdr.PathPayment... | go | {
"resource": ""
} |
q181944 | MutatePayment | test | func (m Destination) MutatePayment(o interface{}) error {
switch o := o.(type) {
default:
return errors.New("Unexpected operation type")
case *xdr.PaymentOp:
return setAccountId(m.AddressOrSeed, &o.Destination)
case *xdr.PathPaymentOp:
return setAccountId(m.AddressOrSeed, &o.Destination)
}
return nil
} | go | {
"resource": ""
} |
q181945 | MutatePayment | test | func (m NativeAmount) MutatePayment(o interface{}) (err error) {
switch o := o.(type) {
default:
err = errors.New("Unexpected operation type")
case *xdr.PaymentOp:
o.Amount, err = amount.Parse(m.Amount)
if err != nil {
return
}
o.Asset, err = xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
case *xdr.P... | go | {
"resource": ""
} |
q181946 | MutatePayment | test | func (m PayWithPath) MutatePayment(o interface{}) (err error) {
var pathPaymentOp *xdr.PathPaymentOp
var ok bool
if pathPaymentOp, ok = o.(*xdr.PathPaymentOp); !ok {
return errors.New("Unexpected operation type")
}
// MaxAmount
pathPaymentOp.SendMax, err = amount.Parse(m.MaxAmount)
if err != nil {
return
}... | go | {
"resource": ""
} |
q181947 | MutateAccountMerge | test | func (m Destination) MutateAccountMerge(o *AccountMergeBuilder) error {
return setAccountId(m.AddressOrSeed, &o.Destination)
} | go | {
"resource": ""
} |
q181948 | MustParse | test | func MustParse(v string) xdr.Int64 {
ret, err := Parse(v)
if err != nil {
panic(err)
}
return ret
} | go | {
"resource": ""
} |
q181949 | Parse | test | func Parse(v string) (xdr.Int64, error) {
var f, o, r big.Rat
_, ok := f.SetString(v)
if !ok {
return xdr.Int64(0), fmt.Errorf("cannot parse amount: %s", v)
}
o.SetInt64(One)
r.Mul(&f, &o)
is := r.FloatString(0)
i, err := strconv.ParseInt(is, 10, 64)
if err != nil {
return xdr.Int64(0), err
}
return x... | go | {
"resource": ""
} |
q181950 | String | test | func String(v xdr.Int64) string {
var f, o, r big.Rat
f.SetInt64(int64(v))
o.SetInt64(One)
r.Quo(&f, &o)
return r.FloatString(7)
} | go | {
"resource": ""
} |
q181951 | CreateOffer | test | func CreateOffer(rate Rate, amount Amount) (result ManageOfferBuilder) {
return ManageOffer(false, rate, amount)
} | go | {
"resource": ""
} |
q181952 | CreatePassiveOffer | test | func CreatePassiveOffer(rate Rate, amount Amount) (result ManageOfferBuilder) {
return ManageOffer(true, rate, amount)
} | go | {
"resource": ""
} |
q181953 | UpdateOffer | test | func UpdateOffer(rate Rate, amount Amount, offerID OfferID) (result ManageOfferBuilder) {
return ManageOffer(false, rate, amount, offerID)
} | go | {
"resource": ""
} |
q181954 | DeleteOffer | test | func DeleteOffer(rate Rate, offerID OfferID) (result ManageOfferBuilder) {
return ManageOffer(false, rate, Amount("0"), offerID)
} | go | {
"resource": ""
} |
q181955 | ManageOffer | test | func ManageOffer(passiveOffer bool, muts ...interface{}) (result ManageOfferBuilder) {
result.PassiveOffer = passiveOffer
result.Mutate(muts...)
return
} | go | {
"resource": ""
} |
q181956 | Mutate | test | func (b *ManageOfferBuilder) Mutate(muts ...interface{}) {
for _, m := range muts {
var err error
switch mut := m.(type) {
case ManageOfferMutator:
if b.PassiveOffer {
err = mut.MutateManageOffer(&b.PO)
} else {
err = mut.MutateManageOffer(&b.MO)
}
case OperationMutator:
err = mut.MutateOpe... | go | {
"resource": ""
} |
q181957 | MutateManageOffer | test | func (m Amount) MutateManageOffer(o interface{}) (err error) {
switch o := o.(type) {
default:
err = errors.New("Unexpected operation type")
case *xdr.ManageOfferOp:
o.Amount, err = amount.Parse(string(m))
case *xdr.CreatePassiveOfferOp:
o.Amount, err = amount.Parse(string(m))
}
return
} | go | {
"resource": ""
} |
q181958 | MutateManageOffer | test | func (m OfferID) MutateManageOffer(o interface{}) (err error) {
switch o := o.(type) {
default:
err = errors.New("Unexpected operation type")
case *xdr.ManageOfferOp:
o.OfferId = xdr.Uint64(m)
}
return
} | go | {
"resource": ""
} |
q181959 | MutateManageOffer | test | func (m Rate) MutateManageOffer(o interface{}) (err error) {
switch o := o.(type) {
default:
err = errors.New("Unexpected operation type")
case *xdr.ManageOfferOp:
o.Selling, err = m.Selling.ToXdrObject()
if err != nil {
return
}
o.Buying, err = m.Buying.ToXdrObject()
if err != nil {
return
}
... | go | {
"resource": ""
} |
q181960 | MutateOperation | test | func (m SourceAccount) MutateOperation(o *xdr.Operation) error {
o.SourceAccount = &xdr.AccountId{}
return setAccountId(m.AddressOrSeed, o.SourceAccount)
} | go | {
"resource": ""
} |
q181961 | String | test | func (p *Price) String() string {
return big.NewRat(int64(p.N), int64(p.D)).FloatString(7)
} | go | {
"resource": ""
} |
q181962 | Transaction | test | func Transaction(muts ...TransactionMutator) (result *TransactionBuilder) {
result = &TransactionBuilder{}
result.Mutate(muts...)
result.Mutate(Defaults{})
return
} | go | {
"resource": ""
} |
q181963 | Mutate | test | func (b *TransactionBuilder) Mutate(muts ...TransactionMutator) {
if b.TX == nil {
b.TX = &xdr.Transaction{}
}
for _, m := range muts {
err := m.MutateTransaction(b)
if err != nil {
b.Err = err
return
}
}
} | go | {
"resource": ""
} |
q181964 | Hash | test | func (b *TransactionBuilder) Hash() ([32]byte, error) {
var txBytes bytes.Buffer
_, err := fmt.Fprintf(&txBytes, "%s", b.NetworkID)
if err != nil {
return [32]byte{}, err
}
_, err = xdr.Marshal(&txBytes, xdr.EnvelopeTypeEnvelopeTypeTx)
if err != nil {
return [32]byte{}, err
}
_, err = xdr.Marshal(&txByte... | go | {
"resource": ""
} |
q181965 | HashHex | test | func (b *TransactionBuilder) HashHex() (string, error) {
hash, err := b.Hash()
if err != nil {
return "", err
}
return hex.EncodeToString(hash[:]), nil
} | go | {
"resource": ""
} |
q181966 | Sign | test | func (b *TransactionBuilder) Sign(signers ...string) (result TransactionEnvelopeBuilder) {
result.Mutate(b)
for _, s := range signers {
result.Mutate(Sign{s})
}
return
} | go | {
"resource": ""
} |
q181967 | MutateTransaction | test | func (m AllowTrustBuilder) MutateTransaction(o *TransactionBuilder) error {
if m.Err != nil {
return m.Err
}
m.O.Body, m.Err = xdr.NewOperationBody(xdr.OperationTypeAllowTrust, m.AT)
o.TX.Operations = append(o.TX.Operations, m.O)
return m.Err
} | go | {
"resource": ""
} |
q181968 | MutateTransaction | test | func (m ChangeTrustBuilder) MutateTransaction(o *TransactionBuilder) error {
if m.Err != nil {
return m.Err
}
m.O.Body, m.Err = xdr.NewOperationBody(xdr.OperationTypeChangeTrust, m.CT)
o.TX.Operations = append(o.TX.Operations, m.O)
return m.Err
} | go | {
"resource": ""
} |
q181969 | MutateTransaction | test | func (m CreateAccountBuilder) MutateTransaction(o *TransactionBuilder) error {
if m.Err != nil {
return m.Err
}
m.O.Body, m.Err = xdr.NewOperationBody(xdr.OperationTypeCreateAccount, m.CA)
o.TX.Operations = append(o.TX.Operations, m.O)
return m.Err
} | go | {
"resource": ""
} |
q181970 | MutateTransaction | test | func (m Defaults) MutateTransaction(o *TransactionBuilder) error {
if o.TX.Fee == 0 {
o.TX.Fee = xdr.Uint32(100 * len(o.TX.Operations))
}
if o.NetworkID == [32]byte{} {
o.NetworkID = DefaultNetwork.ID()
}
return nil
} | go | {
"resource": ""
} |
q181971 | MutateTransaction | test | func (m InflationBuilder) MutateTransaction(o *TransactionBuilder) error {
if m.Err != nil {
return m.Err
}
m.O.Body, m.Err = xdr.NewOperationBody(xdr.OperationTypeInflation, nil)
o.TX.Operations = append(o.TX.Operations, m.O)
return m.Err
} | go | {
"resource": ""
} |
q181972 | MutateTransaction | test | func (m ManageDataBuilder) MutateTransaction(o *TransactionBuilder) error {
if m.Err != nil {
return m.Err
}
m.O.Body, m.Err = xdr.NewOperationBody(xdr.OperationTypeManageData, m.MD)
o.TX.Operations = append(o.TX.Operations, m.O)
return m.Err
} | go | {
"resource": ""
} |
q181973 | MutateTransaction | test | func (m ManageOfferBuilder) MutateTransaction(o *TransactionBuilder) error {
if m.Err != nil {
return m.Err
}
if m.PassiveOffer {
m.O.Body, m.Err = xdr.NewOperationBody(xdr.OperationTypeCreatePassiveOffer, m.PO)
o.TX.Operations = append(o.TX.Operations, m.O)
} else {
m.O.Body, m.Err = xdr.NewOperationBody(... | go | {
"resource": ""
} |
q181974 | MutateTransaction | test | func (m MemoHash) MutateTransaction(o *TransactionBuilder) (err error) {
o.TX.Memo, err = xdr.NewMemo(xdr.MemoTypeMemoHash, m.Value)
return
} | go | {
"resource": ""
} |
q181975 | MutateTransaction | test | func (m MemoID) MutateTransaction(o *TransactionBuilder) (err error) {
o.TX.Memo, err = xdr.NewMemo(xdr.MemoTypeMemoId, xdr.Uint64(m.Value))
return
} | go | {
"resource": ""
} |
q181976 | MutateTransaction | test | func (m MemoReturn) MutateTransaction(o *TransactionBuilder) (err error) {
o.TX.Memo, err = xdr.NewMemo(xdr.MemoTypeMemoReturn, m.Value)
return
} | go | {
"resource": ""
} |
q181977 | MutateTransaction | test | func (m MemoText) MutateTransaction(o *TransactionBuilder) (err error) {
if len([]byte(m.Value)) > MemoTextMaxLength {
err = errors.New("Memo too long; over 28 bytes")
return
}
o.TX.Memo, err = xdr.NewMemo(xdr.MemoTypeMemoText, m.Value)
return
} | go | {
"resource": ""
} |
q181978 | MutateTransaction | test | func (m Network) MutateTransaction(o *TransactionBuilder) error {
o.NetworkID = m.ID()
return nil
} | go | {
"resource": ""
} |
q181979 | MutateTransaction | test | func (m PaymentBuilder) MutateTransaction(o *TransactionBuilder) error {
if m.Err != nil {
return m.Err
}
if m.PathPayment {
m.O.Body, m.Err = xdr.NewOperationBody(xdr.OperationTypePathPayment, m.PP)
o.TX.Operations = append(o.TX.Operations, m.O)
return m.Err
}
m.O.Body, m.Err = xdr.NewOperationBody(xdr.... | go | {
"resource": ""
} |
q181980 | MutateTransaction | test | func (m SetOptionsBuilder) MutateTransaction(o *TransactionBuilder) error {
if m.Err != nil {
return m.Err
}
m.O.Body, m.Err = xdr.NewOperationBody(xdr.OperationTypeSetOptions, m.SO)
o.TX.Operations = append(o.TX.Operations, m.O)
return m.Err
} | go | {
"resource": ""
} |
q181981 | MutateTransaction | test | func (m Sequence) MutateTransaction(o *TransactionBuilder) error {
o.TX.SeqNum = xdr.SequenceNumber(m.Sequence)
return nil
} | go | {
"resource": ""
} |
q181982 | MutateTransaction | test | func (m SourceAccount) MutateTransaction(o *TransactionBuilder) error {
return setAccountId(m.AddressOrSeed, &o.TX.SourceAccount)
} | go | {
"resource": ""
} |
q181983 | Scan | test | func (t *Int64) Scan(src interface{}) error {
val, ok := src.(int64)
if !ok {
return errors.New("Invalid value for xdr.Int64")
}
*t = Int64(val)
return nil
} | go | {
"resource": ""
} |
q181984 | InitialState | test | func (b *Bundle) InitialState(key xdr.LedgerKey) (*xdr.LedgerEntry, error) {
all := b.Changes(key)
if len(all) == 0 {
return nil, ErrMetaNotFound
}
first := all[0]
if first.Type != xdr.LedgerEntryChangeTypeLedgerEntryState {
return nil, nil
}
result := first.MustState()
return &result, nil
} | go | {
"resource": ""
} |
q181985 | Changes | test | func (b *Bundle) Changes(target xdr.LedgerKey) (ret []xdr.LedgerEntryChange) {
return b.changes(target, math.MaxInt32)
} | go | {
"resource": ""
} |
q181986 | StateAfter | test | func (b *Bundle) StateAfter(key xdr.LedgerKey, opidx int) (*xdr.LedgerEntry, error) {
all := b.changes(key, opidx)
if len(all) == 0 {
return nil, ErrMetaNotFound
}
change := all[len(all)-1]
switch change.Type {
case xdr.LedgerEntryChangeTypeLedgerEntryCreated:
entry := change.MustCreated()
return &entry,... | go | {
"resource": ""
} |
q181987 | changes | test | func (b *Bundle) changes(target xdr.LedgerKey, maxOp int) (ret []xdr.LedgerEntryChange) {
for _, change := range b.FeeMeta {
key := change.LedgerKey()
if !key.Equals(target) {
continue
}
ret = append(ret, change)
}
for i, op := range b.TransactionMeta.MustOperations() {
if i > maxOp {
break
}
... | go | {
"resource": ""
} |
q181988 | MustDecode | test | func MustDecode(expected VersionByte, src string) []byte {
d, err := Decode(expected, src)
if err != nil {
panic(err)
}
return d
} | go | {
"resource": ""
} |
q181989 | Encode | test | func Encode(version VersionByte, src []byte) (string, error) {
if err := checkValidVersionByte(version); err != nil {
return "", err
}
var raw bytes.Buffer
// write version byte
if err := binary.Write(&raw, binary.LittleEndian, version); err != nil {
return "", err
}
// write payload
if _, err := raw.Wri... | go | {
"resource": ""
} |
q181990 | MustEncode | test | func MustEncode(version VersionByte, src []byte) string {
e, err := Encode(version, src)
if err != nil {
panic(err)
}
return e
} | go | {
"resource": ""
} |
q181991 | checkValidVersionByte | test | func checkValidVersionByte(version VersionByte) error {
if version == VersionByteAccountID {
return nil
}
if version == VersionByteSeed {
return nil
}
return ErrInvalidVersionByte
} | go | {
"resource": ""
} |
q181992 | Checksum | test | func Checksum(data []byte) []byte {
var crc uint16
var out bytes.Buffer
for _, b := range data {
crc = ((crc << 8) & 0xffff) ^ crc16tab[((crc>>8)^uint16(b))&0x00FF]
}
err := binary.Write(&out, binary.LittleEndian, crc)
if err != nil {
panic(err)
}
return out.Bytes()
} | go | {
"resource": ""
} |
q181993 | Validate | test | func Validate(data []byte, expected []byte) error {
actual := Checksum(data)
// validate the provided checksum against the calculated
if !bytes.Equal(actual, expected) {
return ErrInvalidChecksum
}
return nil
} | go | {
"resource": ""
} |
q181994 | LedgerKey | test | func (change *LedgerEntryChange) LedgerKey() LedgerKey {
switch change.Type {
case LedgerEntryChangeTypeLedgerEntryCreated:
change := change.MustCreated()
return change.LedgerKey()
case LedgerEntryChangeTypeLedgerEntryRemoved:
return change.MustRemoved()
case LedgerEntryChangeTypeLedgerEntryUpdated:
change ... | go | {
"resource": ""
} |
q181995 | checkPlausible | test | func checkPlausible() {
for _, r := range prefix {
if !strings.ContainsRune(alphabet, r) {
fmt.Printf("Invalid prefix: %s is not in the base32 alphabet\n", strconv.QuoteRune(r))
os.Exit(1)
}
}
} | go | {
"resource": ""
} |
q181996 | Address | test | func (aid *AccountId) Address() string {
if aid == nil {
return ""
}
switch aid.Type {
case CryptoKeyTypeKeyTypeEd25519:
ed := aid.MustEd25519()
raw := make([]byte, 32)
copy(raw, ed[:])
return strkey.MustEncode(strkey.VersionByteAccountID, raw)
default:
panic(fmt.Errorf("Unknown account id type: %v", ... | go | {
"resource": ""
} |
q181997 | Equals | test | func (aid *AccountId) Equals(other AccountId) bool {
if aid.Type != other.Type {
return false
}
switch aid.Type {
case CryptoKeyTypeKeyTypeEd25519:
l := aid.MustEd25519()
r := other.MustEd25519()
return l == r
default:
panic(fmt.Errorf("Unknown account id type: %v", aid.Type))
}
} | go | {
"resource": ""
} |
q181998 | SetAddress | test | func (aid *AccountId) SetAddress(address string) error {
if aid == nil {
return nil
}
raw, err := strkey.Decode(strkey.VersionByteAccountID, address)
if err != nil {
return err
}
if len(raw) != 32 {
return errors.New("invalid address")
}
var ui Uint256
copy(ui[:], raw)
*aid, err = NewAccountId(Crypt... | go | {
"resource": ""
} |
q181999 | ToXdrObject | test | func (a Asset) ToXdrObject() (xdr.Asset, error) {
if a.Native {
return xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
}
var issuer xdr.AccountId
err := setAccountId(a.Issuer, &issuer)
if err != nil {
return xdr.Asset{}, err
}
length := len(a.Code)
switch {
case length >= 1 && length <= 4:
var codeArra... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.