_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: "!@#$%^&*()-_=+,.?/:;{}[]~",
}
return p
}
|
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 + p.MinDigits + p.MinSpclChars
// Min length is the collective min length
if collectiveMinLength > p.MinLength {
p.MinLength = collectiveMinLength
}
// Max length should be greater than collective minimun length
if p.MinLength > p.MaxLength {
return "", ErrMaxLengthExceeded
}
if p.MaxLength == 0 {
return "", nil
}
capsAlpha := []byte(p.UpperPool)
smallAlpha := []byte(p.LowerPool)
digits := []byte(p.DigitPool)
spclChars := []byte(p.SpclCharPool)
allChars := []byte(p.UpperPool + p.LowerPool + p.DigitPool + p.SpclCharPool)
passwd := CreateRandom(capsAlpha, p.MinUppers)
passwd = append(passwd, CreateRandom(smallAlpha, p.MinLowers)...)
passwd = append(passwd, CreateRandom(digits, p.MinDigits)...)
passwd = append(passwd, CreateRandom(spclChars, p.MinSpclChars)...)
passLen := len(passwd)
if passLen < p.MaxLength {
randLength := random(p.MinLength, p.MaxLength)
passwd = append(passwd, CreateRandom(allChars, randLength-passLen)...)
}
Shuffle(passwd)
return string(passwd), nil
}
|
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 == nil {
s.shutdownSigs = []os.Signal{os.Interrupt}
}
// ensure errf set
if s.errf == nil {
s.errf = func(str string, v ...interface{}) {
s.logf("ERROR: "+str, v...)
}
}
return s, nil
}
|
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 func() error {
return f(ctxt)
}
}(f))
}
// add shutdown
eg.Go(func() func() error {
s.sig = make(chan os.Signal, 1)
signal.Notify(s.sig, s.shutdownSigs...)
return func() error {
s.logf("received signal: %v", <-s.sig)
return s.Shutdown()
}
}())
if err := eg.Wait(); err != nil && !s.ShutdownIgnore(err) {
return err
}
return nil
}
|
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
}
}
}
return firstErr
}
|
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, shutdown)
if err != nil {
return err
}
s.ignoreErrors = append(s.ignoreErrors, ignore...)
return nil
}
|
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 err = s.Register(mux, mux, IgnoreListenerClosed, IgnoreNetOpError); err != nil {
return nil, err
}
return mux, nil
}
|
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); err != nil {
return err
}
}
// register server
return s.Register(func() error {
return server.Serve(listener)
}, server.Shutdown, IgnoreServerClosed, IgnoreNetOpError)
}
|
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()
return nil
}
case func() error:
t = func(context.Context) error {
return f()
}
}
if t == nil {
return nil, ErrInvalidType
}
o = append(o, t)
}
return o, nil
}
|
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), handlers.countHandler).Methods("GET")
m.HandleFunc(fmt.Sprintf("/%s/__ids", path), handlers.idsHandler).Methods("GET")
m.HandleFunc(fmt.Sprintf("/%s/{uuid}", path), handlers.getHandler).Methods("GET")
m.HandleFunc(fmt.Sprintf("/%s/{uuid}", path), handlers.putHandler).Methods("PUT")
m.HandleFunc(fmt.Sprintf("/%s/{uuid}", path), handlers.deleteHandler).Methods("DELETE")
gtgChecker = append(gtgChecker, func() gtg.Status {
if err := service.Check(); err != nil {
return gtg.Status{GoodToGo: false, Message: err.Error()}
}
return gtg.Status{GoodToGo: true}
})
}
if apiData != nil && len(apiData) != 0 {
endpoint, err := api.NewAPIEndpointForYAML(apiData)
if err != nil {
log.Warn("Failed to serve API endpoint, please check whether the OpenAPI file is valid")
} else {
m.HandleFunc(api.DefaultPath, endpoint.ServeHTTP)
}
}
m.HandleFunc("/__health", healthHandler)
// The top one of these feels more correct, but the lower one matches what we have in Dropwizard,
// so it's what apps expect currently
m.HandleFunc(status.PingPath, status.PingHandler)
m.HandleFunc(status.PingPathDW, status.PingHandler)
// The top one of these feels more correct, but the lower one matches what we have in Dropwizard,
// so it's what apps expect currently same as ping, the content of build-info needs more definition
m.HandleFunc(status.BuildInfoPath, status.BuildInfoHandler)
m.HandleFunc(status.BuildInfoPathDW, status.BuildInfoHandler)
m.HandleFunc(status.GTGPath, status.NewGoodToGoHandler(gtg.FailFastParallelCheck(gtgChecker)))
return m
}
|
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.Elem()
}
if t.Kind() == reflect.Struct {
result = copyStruct(reflect.ValueOf(data), t).Interface()
} else {
result = data
}
b, err := json.Marshal(result)
return b, err
}
|
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.NewDecoder(req.Body).Decode(jsonStruct.Interface()); err != nil {
errors.Overall[DeserializationError] = err.Error()
}
validateAndMap(jsonStruct, context, errors, ifacePtr...)
}
}
|
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[headerAllowOrigin] = "*"
} else {
headers[headerAllowOrigin] = origin
}
// add allow credentials
headers[headerAllowCredentials] = strconv.FormatBool(o.AllowCredentials)
// add allow methods
if len(o.AllowMethods) > 0 {
headers[headerAllowMethods] = strings.Join(o.AllowMethods, ",")
}
// add allow headers
if len(o.AllowHeaders) > 0 {
// TODO: Add default headers
headers[headerAllowHeaders] = strings.Join(o.AllowHeaders, ",")
}
// add exposed header
if len(o.ExposeHeaders) > 0 {
headers[headerExposeHeaders] = strings.Join(o.ExposeHeaders, ",")
}
// add a max age header
if o.MaxAge > time.Duration(0) {
headers[headerMaxAge] = strconv.FormatInt(int64(o.MaxAge/time.Second), 10)
}
return
}
|
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 method == rMethod {
headers[headerAllowMethods] = strings.Join(o.AllowMethods, ",")
break
}
}
// verify if requested headers are allowed
var allowed []string
for _, rHeader := range strings.Split(rHeaders, ",") {
lookupLoop:
for _, allowedHeader := range o.AllowHeaders {
if rHeader == allowedHeader {
allowed = append(allowed, rHeader)
break lookupLoop
}
}
}
// add allowed headers
if len(allowed) > 0 {
headers[headerAllowHeaders] = strings.Join(allowed, ",")
}
// add exposed headers
if len(o.ExposeHeaders) > 0 {
headers[headerExposeHeaders] = strings.Join(o.ExposeHeaders, ",")
}
// add a max age header
if o.MaxAge > time.Duration(0) {
headers[headerMaxAge] = strconv.FormatInt(int64(o.MaxAge/time.Second), 10)
}
return
}
|
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
// to the response.
headers map[string]string
)
if req.Method == "OPTIONS" &&
(requestedMethod != "" || requestedHeaders != "") {
// TODO: if preflight, respond with exact headers if allowed
headers = opts.PreflightHeader(origin, requestedMethod, requestedHeaders)
} else {
headers = opts.Header(origin)
}
for key, value := range headers {
res.Header().Set(key, value)
}
}
}
|
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, _ := t.Clone()
c.MapTo(&renderer{res, req, tc, opt, cs}, (*Render)(nil))
}
}
|
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 output.String()
}
|
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, languageRange := range acceptLanguageHeaderValues {
// Check if a given range is qualified or not
if qualifiedRange := strings.Split(languageRange, ";q="); len(qualifiedRange) == 2 {
quality, error := strconv.ParseFloat(qualifiedRange[1], 32)
if error != nil {
// When the quality is unparseable, assume it's 1
acceptLanguages[i] = AcceptLanguage{trimLanguage(qualifiedRange[0]), 1}
} else {
acceptLanguages[i] = AcceptLanguage{trimLanguage(qualifiedRange[0]), float32(quality)}
}
} else {
acceptLanguages[i] = AcceptLanguage{trimLanguage(languageRange), 1}
}
}
sort.Sort(acceptLanguages)
context.Map(acceptLanguages)
} else {
// If we have no Accept-Language header just map an empty slice
context.Map(make(AcceptLanguages, 0))
}
}
}
|
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("WWW-Authenticate", "Basic realm=\"Authorization Required\"")
http.Error(res, "Not Authorized", http.StatusUnauthorized)
}
}
}
|
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
}
result = xdr.AccountId(pk)
return
}
|
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 {
mutators = append(mutators, MaxLimit)
}
return ChangeTrust(mutators...)
}
|
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.PathPaymentOp:
o.DestAmount, err = amount.Parse(m.Amount)
if err != nil {
return
}
o.DestAsset, err = createAlphaNumAsset(m.Code, m.Issuer)
}
return
}
|
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.PathPaymentOp:
o.DestAmount, err = amount.Parse(m.Amount)
if err != nil {
return
}
o.DestAsset, err = xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
}
return
}
|
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
}
// Path
var path []xdr.Asset
var xdrAsset xdr.Asset
for _, asset := range m.Path {
xdrAsset, err = asset.ToXdrObject()
if err != nil {
return err
}
path = append(path, xdrAsset)
}
pathPaymentOp.Path = path
// Asset
pathPaymentOp.SendAsset, err = m.Asset.ToXdrObject()
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 xdr.Int64(i), nil
}
|
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.MutateOperation(&b.O)
default:
err = errors.New("Mutator type not allowed")
}
if err != nil {
b.Err = err
return
}
}
}
|
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
}
o.Price, err = price.Parse(string(m.Price))
case *xdr.CreatePassiveOfferOp:
o.Selling, err = m.Selling.ToXdrObject()
if err != nil {
return
}
o.Buying, err = m.Buying.ToXdrObject()
if err != nil {
return
}
o.Price, err = price.Parse(string(m.Price))
}
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(&txBytes, b.TX)
if err != nil {
return [32]byte{}, err
}
return hash.Hash(txBytes.Bytes()), nil
}
|
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(xdr.OperationTypeManageOffer, m.MO)
o.TX.Operations = append(o.TX.Operations, m.O)
}
return m.Err
}
|
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.OperationTypePayment, m.P)
o.TX.Operations = append(o.TX.Operations, m.O)
return m.Err
}
|
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, nil
case xdr.LedgerEntryChangeTypeLedgerEntryRemoved:
return nil, nil
case xdr.LedgerEntryChangeTypeLedgerEntryUpdated:
entry := change.MustUpdated()
return &entry, nil
case xdr.LedgerEntryChangeTypeLedgerEntryState:
// scott: stellar-core should not emit a lone state entry, and we are
// retrieving changes from the end of the collection. If this situation
// occurs, it means that I didn't understand something correctly or there is
// a bug in stellar-core.
panic(fmt.Errorf("Unexpected 'state' entry"))
default:
panic(fmt.Errorf("Unknown change type: %v", change.Type))
}
}
|
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
}
for _, change := range op.Changes {
key := change.LedgerKey()
if !key.Equals(target) {
continue
}
ret = append(ret, change)
}
}
return
}
|
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.Write(src); err != nil {
return "", err
}
// calculate and write checksum
checksum := crc16.Checksum(raw.Bytes())
if _, err := raw.Write(checksum); err != nil {
return "", err
}
result := base32.StdEncoding.EncodeToString(raw.Bytes())
return result, nil
}
|
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 := change.MustUpdated()
return change.LedgerKey()
case LedgerEntryChangeTypeLedgerEntryState:
change := change.MustState()
return change.LedgerKey()
default:
panic(fmt.Errorf("Unknown change type: %v", change.Type))
}
}
|
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", aid.Type))
}
}
|
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(CryptoKeyTypeKeyTypeEd25519, ui)
return err
}
|
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 codeArray [4]byte
byteArray := []byte(a.Code)
copy(codeArray[:], byteArray[0:length])
asset := xdr.AssetAlphaNum4{codeArray, issuer}
return xdr.NewAsset(xdr.AssetTypeAssetTypeCreditAlphanum4, asset)
case length >= 5 && length <= 12:
var codeArray [12]byte
byteArray := []byte(a.Code)
copy(codeArray[:], byteArray[0:length])
asset := xdr.AssetAlphaNum12{codeArray, issuer}
return xdr.NewAsset(xdr.AssetTypeAssetTypeCreditAlphanum12, asset)
default:
return xdr.Asset{}, errors.New("Asset code length is invalid")
}
}
|
go
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.